Rename token to move to socket-protocol repo

src/superToken/ISuperToken.sol → src/going-multichain-erc20/IMultichainToken.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-interface ISuperToken {
+interface IMultichainToken {
     function burn(address user_, uint256 amount_) external;
 
     function mint(address receiver_, uint256 amount_) external;

src/superToken/ISuperTokenDeployer.sol → src/going-multichain-erc20/IMultichainTokenDeployer.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-interface ISuperTokenDeployer {
-    function superToken() external view returns (bytes32);
+interface IMultichainTokenDeployer {
+    function multichainToken() external view returns (bytes32);
 
     function vault() external view returns (bytes32);
 

src/superToken/SuperToken.sol → src/going-multichain-erc20/MultichainToken.sol

@@ -4,11 +4,11 @@ pragma solidity ^0.8.13;
 import "solady/tokens/ERC20.sol";
 
 /**
- * @title SuperToken
+ * @title MultichainToken
  * @notice An ERC20 contract which enables bridging a token to its sibling chains.
  * @dev Implements a custom ERC20 token with minting and burning capabilities restricted to a socket address
  */
-contract SuperToken is ERC20 {
+contract MultichainToken is ERC20 {
     string private _name;
     string private _symbol;
     uint8 private _decimals;

src/superToken/SuperTokenAppGateway.sol → src/going-multichain-erc20/MultichainTokenAppGateway.sol

@@ -5,16 +5,16 @@ import "solady/auth/Ownable.sol";
 import "socket-protocol/contracts/base/AppGatewayBase.sol";
 import "socket-protocol/contracts/interfaces/IForwarder.sol";
 
-import {ISuperToken} from "./ISuperToken.sol";
+import {IMultichainToken} from "./IMultichainToken.sol";
 import {IVault} from "./IVault.sol";
-import {ISuperTokenDeployer} from "./ISuperTokenDeployer.sol";
+import {IMultichainTokenDeployer} from "./IMultichainTokenDeployer.sol";
 
 /**
- * @title SuperTokenApp
+ * @title MultichainTokenApp
  * @notice A cross-chain application for bridging tokens
  * @dev Extends AppGatewayBase and Ownable to provide a chain abstracted token bridging functionality
  */
-contract SuperTokenAppGateway is AppGatewayBase, Ownable {
+contract MultichainTokenAppGateway is AppGatewayBase, Ownable {
     /**
      * @notice Counter to track unique transaction IDs
      * @dev Incremented with each bridging operation
@@ -49,7 +49,7 @@ contract SuperTokenAppGateway is AppGatewayBase, Ownable {
     event Bridged(bytes32 asyncId);
 
     /**
-     * @notice Constructor to initialize the SuperTokenApp
+     * @notice Constructor to initialize the MultichainTokenApp
      * @param _addressResolver Address of the cross-chain address resolver
      * @param deployerContract_ Address of the contract deployer
      * @param feesData_ Struct containing fee-related data for bridging
@@ -59,7 +59,7 @@ contract SuperTokenAppGateway is AppGatewayBase, Ownable {
         AppGatewayBase(_addressResolver)
         Ownable()
     {
-        ISuperTokenDeployer deployer = ISuperTokenDeployer(deployerContract_);
+        IMultichainTokenDeployer deployer = IMultichainTokenDeployer(deployerContract_);
         baseChainSlug = deployer.baseChainSlug();
         vault = deployer.forwarderAddresses(deployer.vault(), baseChainSlug);
 
@@ -99,28 +99,28 @@ contract SuperTokenAppGateway is AppGatewayBase, Ownable {
         // Check user balance on src chain
         _readCallOn();
         // Request to forwarder and deploys immutable promise contract and stores it
-        ISuperToken(order.srcToken).balanceOf(order.srcUser);
+        IMultichainToken(order.srcToken).balanceOf(order.srcUser);
         IPromise(order.srcToken).then(this.checkBalance.selector, abi.encode(order, asyncId));
 
         _readCallOff();
 
         // if same-chain transfer
         if (order.srcToken == order.dstToken) {
-            ISuperToken(order.srcToken).transferFrom(order.srcUser, order.dstUser, order.srcAmount);
+            IMultichainToken(order.srcToken).transferFrom(order.srcUser, order.dstUser, order.srcAmount);
         } else {
             // | src \ dst  | baseChain     | other        |
             // |------------|---------------|--------------|
             // | baseChain  | transfer      | deposit/mint |
             // | other      | burn/withdraw | burn/mint    |
             if (IForwarder(order.srcToken).getChainSlug() == baseChainSlug) {
                 IVault(vault).deposit(order.srcAmount, order.srcUser);
-                ISuperToken(order.dstToken).mint(order.dstUser, order.srcAmount);
+                IMultichainToken(order.dstToken).mint(order.dstUser, order.srcAmount);
             } else if (IForwarder(order.dstToken).getChainSlug() == baseChainSlug) {
-                ISuperToken(order.srcToken).burn(order.srcUser, order.srcAmount);
+                IMultichainToken(order.srcToken).burn(order.srcUser, order.srcAmount);
                 IVault(vault).withdraw(order.srcAmount, order.dstUser);
             } else {
-                ISuperToken(order.srcToken).burn(order.srcUser, order.srcAmount);
-                ISuperToken(order.dstToken).mint(order.dstUser, order.srcAmount);
+                IMultichainToken(order.srcToken).burn(order.srcUser, order.srcAmount);
+                IMultichainToken(order.dstToken).mint(order.dstUser, order.srcAmount);
             }
         }
 

src/superToken/SuperTokenDeployer.sol → src/going-multichain-erc20/MultichainTokenDeployer.sol

@@ -3,26 +3,26 @@ pragma solidity ^0.8.13;
 
 import "socket-protocol/contracts/base/AppDeployerBase.sol";
 import "solady/auth/Ownable.sol";
-import "./SuperToken.sol";
+import "./MultichainToken.sol";
 import "./Vault.sol";
 
 /**
- * @title SuperTokenDeployer
- * @notice A contract for deploying SuperToken across multiple chains
+ * @title MultichainTokenDeployer
+ * @notice A contract for deploying MultichainToken across multiple chains
  * @dev Extends AppDeployerBase and Ownable to provide cross-chain token deployment functionality
  */
-contract SuperTokenDeployer is AppDeployerBase, Ownable {
+contract MultichainTokenDeployer is AppDeployerBase, Ownable {
     /**
-     * @notice Unique identifier for the SuperToken contract
-     * @dev Used to track and manage the SuperToken contract across different chains
+     * @notice Unique identifier for the MultichainToken contract
+     * @dev Used to track and manage the MultichainToken contract across different chains
      */
-    bytes32 public immutable superToken = _createContractId("superToken");
+    bytes32 public immutable multichainToken = _createContractId("multichainToken");
     bytes32 public immutable vault = _createContractId("vault");
     uint32 public baseChainSlug;
     address public baseTokenAddress;
 
     /**
-     * @notice Constructor to initialize the SuperTokenDeployer
+     * @notice Constructor to initialize the MultichainTokenDeployer
      * @param baseChainSlug_ Chain ID of the original ERC20 already deployed
      * @param baseTokenAddress_ Token address of the original ERC20 already deployed
      * @param addressResolver Address of the address resolver contract
@@ -48,26 +48,26 @@ contract SuperTokenDeployer is AppDeployerBase, Ownable {
 
         _initializeOwner(owner);
 
-        creationCodeWithArgs[superToken] =
-            abi.encodePacked(type(SuperToken).creationCode, abi.encode(name, symbol, decimals));
+        creationCodeWithArgs[multichainToken] =
+            abi.encodePacked(type(MultichainToken).creationCode, abi.encode(name, symbol, decimals));
 
         creationCodeWithArgs[vault] = abi.encodePacked(type(Vault).creationCode, abi.encode(owner, baseTokenAddress_));
 
         _setFeesData(feesData);
     }
 
     /**
-     * @notice Deploys the SuperToken contract on a specified chain
+     * @notice Deploys the MultichainToken contract on a specified chain
      * @param chainSlug The unique identifier of the target blockchain
-     * @dev Triggers the deployment of the SuperToken contract
+     * @dev Triggers the deployment of the MultichainToken contract
      * @custom:modifier Accessible to contract owner or authorized deployers
      */
     function deployContracts(uint32 chainSlug) external async {
         if (chainSlug == baseChainSlug) {
             addressResolver.deployForwarderContract(address(this), baseTokenAddress, chainSlug);
             _deploy(vault, chainSlug);
         } else {
-            _deploy(superToken, chainSlug);
+            _deploy(multichainToken, chainSlug);
         }
     }
 

test/SuperToken.t.sol → test/MultichainToken.t.sol

@@ -3,25 +3,25 @@ pragma solidity ^0.8.13;
 
 import "socket-protocol/test/AuctionHouse.sol";
 
-import {SuperTokenDeployer} from "../src/superToken/SuperTokenDeployer.sol";
-import {SuperTokenAppGateway} from "../src/superToken/SuperTokenAppGateway.sol";
+import {MultichainTokenDeployer} from "../src/going-multichain-erc20/MultichainTokenDeployer.sol";
+import {MultichainTokenAppGateway} from "../src/going-multichain-erc20/MultichainTokenAppGateway.sol";
 
 import {MockERC20} from "./mocks/MockERC20.sol";
 
-contract SuperTokenTest is AuctionHouseTest {
+contract MultichainTokenTest is AuctionHouseTest {
     uint256 srcAmount = 0.01 ether;
 
     MockERC20 public token;
 
     struct AppContracts {
-        SuperTokenAppGateway superTokenApp;
-        SuperTokenDeployer superTokenDeployer;
-        bytes32 superToken;
+        MultichainTokenAppGateway multichainTokenApp;
+        MultichainTokenDeployer multichainTokenDeployer;
+        bytes32 multichainToken;
         bytes32 vault;
     }
 
     AppContracts appContracts;
-    SuperTokenAppGateway.UserOrder userOrder;
+    MultichainTokenAppGateway.UserOrder userOrder;
 
     event BatchCancelled(bytes32 indexed asyncId);
     event FinalizeRequested(bytes32 indexed payloadId, AsyncRequest asyncRequest);
@@ -35,11 +35,11 @@ contract SuperTokenTest is AuctionHouseTest {
         token.mint(address(this), 1000 * 10 ** 18);
 
         // Deploy Deployer and AppGateway
-        deploySuperTokenApp();
+        deployMultichainTokenApp();
     }
 
-    function deploySuperTokenApp() internal {
-        SuperTokenDeployer superTokenDeployer = new SuperTokenDeployer(
+    function deployMultichainTokenApp() internal {
+        MultichainTokenDeployer multichainTokenDeployer = new MultichainTokenDeployer(
             optChainSlug,
             address(token),
             owner,
@@ -50,14 +50,14 @@ contract SuperTokenTest is AuctionHouseTest {
             createFeesData(maxFees)
         );
 
-        SuperTokenAppGateway superTokenApp =
-            new SuperTokenAppGateway(address(addressResolver), address(superTokenDeployer), createFeesData(maxFees));
+        MultichainTokenAppGateway multichainTokenApp =
+            new MultichainTokenAppGateway(address(addressResolver), address(multichainTokenDeployer), createFeesData(maxFees));
 
         appContracts = AppContracts({
-            superTokenApp: superTokenApp,
-            superTokenDeployer: superTokenDeployer,
-            superToken: superTokenDeployer.superToken(),
-            vault: superTokenDeployer.vault()
+            multichainTokenApp: multichainTokenApp,
+            multichainTokenDeployer: multichainTokenDeployer,
+            multichainToken: multichainTokenDeployer.multichainToken(),
+            vault: multichainTokenDeployer.vault()
         });
     }