feat: custom token registrars

contracts/interfaces/ICanonicalTokenRegistrar.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface ICanonicalTokenRegistrar {
+    error ZeroAddress();
+
+    function chainName() external view returns (string memory);
+
+    function chainNameHash() external view returns (bytes32);
+}

contracts/interfaces/IStandardizedToken.sol

@@ -2,20 +2,35 @@
 
 pragma solidity ^0.8.0;
 
-import { IERC20 } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IERC20.sol';
 import { IContractIdentifier } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/interfaces/IContractIdentifier.sol';
 
 import { IImplementation } from './IImplementation.sol';
 import { IInterchainToken } from './IInterchainToken.sol';
 import { IDistributable } from './IDistributable.sol';
 import { IERC20MintableBurnable } from './IERC20MintableBurnable.sol';
+import { ITokenManager } from './ITokenManager.sol';
+import { IERC20Named } from './IERC20Named.sol';
 
 /**
  * @title StandardizedToken
  * @notice This contract implements a standardized token which extends InterchainToken functionality.
  * This contract also inherits Distributable and Implementation logic.
  */
-interface IStandardizedToken is IImplementation, IInterchainToken, IDistributable, IERC20MintableBurnable, IERC20, IContractIdentifier {
+interface IStandardizedToken is IInterchainToken, IDistributable, IERC20MintableBurnable, IERC20Named, IContractIdentifier {
     error TokenManagerAddressZero();
     error TokenNameEmpty();
+
+    /**
+     * @notice Called by the proxy to setup itself.
+     * @dev This should be hidden by the proxy.
+     * @param params the data to be used for the initialization.
+     */
+    function setup(bytes calldata params) external;
+
+    /**
+     * @notice Getter for the tokenManager used for this token.
+     * @dev Needs to be overwitten.
+     * @return tokenManager_ the TokenManager called to facilitate cross chain transfers.
+     */
+    function tokenManager() external view returns (ITokenManager tokenManager_);
 }

contracts/interfaces/IStandardizedTokenRegistrar.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface IStandardizedTokenRegistrar {
+    error ZeroAddress();
+
+    function chainName() external view returns (string memory);
+
+    function chainNameHash() external view returns (bytes32);
+}

contracts/token-implementations/StandardizedToken.sol

@@ -2,6 +2,7 @@
 
 pragma solidity ^0.8.0;
 
+import { IImplementation } from '../interfaces/IImplementation.sol';
 import { IStandardizedToken } from '../interfaces/IStandardizedToken.sol';
 import { ITokenManager } from '../interfaces/ITokenManager.sol';
 import { IInterchainToken } from '../interfaces/IInterchainToken.sol';
@@ -46,7 +47,7 @@ contract StandardizedToken is InterchainToken, ERC20Permit, Implementation, Dist
      * @notice Returns the token manager for this token
      * @return ITokenManager The token manager contract
      */
-    function tokenManager() public view override(InterchainToken, IInterchainToken) returns (ITokenManager) {
+    function tokenManager() public view override(InterchainToken, IStandardizedToken) returns (ITokenManager) {
         return ITokenManager(tokenManager_);
     }
 
@@ -55,7 +56,7 @@ contract StandardizedToken is InterchainToken, ERC20Permit, Implementation, Dist
      * @param params The setup parameters in bytes
      * The setup params include tokenManager, distributor, tokenName, symbol, decimals, mintAmount and mintTo
      */
-    function setup(bytes calldata params) external override onlyProxy {
+    function setup(bytes calldata params) external override(IImplementation, IStandardizedToken) onlyProxy {
         {
             address distributor_;
             address tokenManagerAddress;

contracts/token-registrars/CanonicalTokenRegistrar.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import { IInterchainTokenService } from '../interfaces/IInterchainTokenService.sol';
+import { ICanonicalTokenRegistrar } from '../interfaces/ICanonicalTokenRegistrar.sol';
+import { ITokenManagerType } from '../interfaces/ITokenManagerType.sol';
+import { IERC20Named } from '../interfaces/IERC20Named.sol';
+
+import { Multicall } from '../utils/Multicall.sol';
+
+contract CanonicalTokenRegistrar is ICanonicalTokenRegistrar, ITokenManagerType, Multicall {
+    IInterchainTokenService public immutable service;
+    string public chainName;
+    bytes32 public immutable chainNameHash;
+
+    bytes32 internal constant PREFIX_CANONICAL_TOKEN_SALT = keccak256('canonical-token-salt');
+
+    constructor(address interchainTokenServiceAddress, string memory chainName_) {
+        if (interchainTokenServiceAddress == address(0)) revert ZeroAddress();
+        service = IInterchainTokenService(interchainTokenServiceAddress);
+        chainName = chainName_;
+        chainNameHash = keccak256(bytes(chainName_));
+    }
+
+    function getCanonicalTokenSalt(address tokenAddress) public view returns (bytes32 salt) {
+        salt = keccak256(abi.encode(PREFIX_CANONICAL_TOKEN_SALT, chainNameHash, tokenAddress));
+    }
+
+    function getCanonicalTokenId(address tokenAddress) public view returns (bytes32 tokenId) {
+        tokenId = service.getCustomTokenId(address(this), getCanonicalTokenSalt(tokenAddress));
+    }
+
+    function registerCanonicalToken(address tokenAddress) external payable returns (bytes32 tokenId) {
+        bytes memory params = abi.encode('', tokenAddress);
+        bytes32 salt = getCanonicalTokenSalt(tokenAddress);
+        tokenId = service.deployCustomTokenManager(salt, TokenManagerType.LOCK_UNLOCK, params);
+    }
+
+    function deployAndRegisterRemoteCanonicalToken(bytes32 salt, string calldata destinationChain, uint256 gasValue) external payable {
+        // This ensures that the token manages has been deployed by this address, so it's safe to trust it.
+        bytes32 tokenId = service.getCustomTokenId(address(this), salt);
+        IERC20Named token = IERC20Named(service.getTokenAddress(tokenId));
+        // The 3 lines below will revert if the token manager does not exist.
+        string memory tokenName = token.name();
+        string memory tokenSymbol = token.symbol();
+        uint8 tokenDecimals = token.decimals();
+
+        // slither-disable-next-line arbitrary-send-eth
+        service.deployAndRegisterRemoteStandardizedToken{ value: gasValue }(
+            salt,
+            tokenName,
+            tokenSymbol,
+            tokenDecimals,
+            '',
+            '',
+            0,
+            '',
+            destinationChain,
+            gasValue
+        );
+    }
+}

contracts/token-registrars/StandardizedTokenRegistrar.sol

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import { SafeTokenTransfer } from '@axelar-network/axelar-gmp-sdk-solidity/contracts/libs/SafeTransfer.sol';
+
+import { IInterchainTokenService } from '../interfaces/IInterchainTokenService.sol';
+import { IStandardizedTokenRegistrar } from '../interfaces/IStandardizedTokenRegistrar.sol';
+import { ITokenManagerType } from '../interfaces/ITokenManagerType.sol';
+import { ITokenManager } from '../interfaces/ITokenManager.sol';
+import { IStandardizedToken } from '../interfaces/IStandardizedToken.sol';
+
+import { Multicall } from '../utils/Multicall.sol';
+
+import { AddressBytesUtils } from '../libraries/AddressBytesUtils.sol';
+
+contract StandardizedTokenRegistrar is IStandardizedTokenRegistrar, ITokenManagerType, Multicall {
+    using AddressBytesUtils for bytes;
+    using AddressBytesUtils for address;
+    using SafeTokenTransfer for IStandardizedToken;
+
+    IInterchainTokenService public immutable service;
+    string public chainName;
+    bytes32 public immutable chainNameHash;
+
+    struct DeployParams {
+        address deployer;
+        bytes distributor;
+        bytes operator;
+    }
+
+    mapping(bytes32 => DeployParams) public deploymentParameterMap;
+
+    bytes32 internal constant PREFIX_STANDARDIZED_TOKEN_SALT = keccak256('standardized-token-salt');
+
+    constructor(address interchainTokenServiceAddress, string memory chainName_) {
+        if (interchainTokenServiceAddress == address(0)) revert ZeroAddress();
+        service = IInterchainTokenService(interchainTokenServiceAddress);
+        chainName = chainName_;
+        chainNameHash = keccak256(bytes(chainName_));
+    }
+
+    function getStandardizedTokenSalt(address deployer, bytes32 salt) public view returns (bytes32) {
+        return keccak256(abi.encode(PREFIX_STANDARDIZED_TOKEN_SALT, chainNameHash, deployer, salt));
+    }
+
+    function getStandardizedTokenId(address deployer, bytes32 salt) public view returns (bytes32 tokenId) {
+        tokenId = service.getCustomTokenId(address(this), getStandardizedTokenSalt(deployer, salt));
+    }
+
+    function getStandardizedTokenAddress(address deployer, bytes32 salt) public view returns (address tokenAddress) {
+        tokenAddress = service.getStandardizedTokenAddress(getStandardizedTokenId(deployer, salt));
+    }
+
+    function deployStandardizedToken(
+        bytes32 salt,
+        string calldata name,
+        string calldata symbol,
+        uint8 decimals,
+        uint256 mintAmount,
+        address distributor
+    ) external payable {
+        address sender = msg.sender;
+        salt = getStandardizedTokenSalt(sender, salt);
+        bytes32 tokenId = service.getCustomTokenId(address(this), salt);
+
+        service.deployAndRegisterStandardizedToken(salt, name, symbol, decimals, mintAmount, distributor);
+        ITokenManager tokenManager = ITokenManager(service.getTokenManagerAddress(tokenId));
+        tokenManager.transferOperatorship(sender);
+
+        IStandardizedToken token = IStandardizedToken(service.getStandardizedTokenAddress(tokenId));
+        token.safeTransfer(sender, mintAmount);
+    }
+
+    function deployRemoteStandarizedToken(
+        bytes32 salt,
+        bool sameDistributor,
+        string memory destinationChain,
+        uint256 gasValue
+    ) external payable {
+        string memory tokenName;
+        string memory tokenSymbol;
+        uint8 tokenDecimals;
+        bytes memory distributor = '';
+        bytes memory operator;
+
+        {
+            address sender = msg.sender;
+            salt = getStandardizedTokenSalt(sender, salt);
+            bytes32 tokenId = service.getCustomTokenId(address(this), salt);
+
+            IStandardizedToken token = IStandardizedToken(service.getStandardizedTokenAddress(tokenId));
+            ITokenManager tokenManager = ITokenManager(service.getTokenManagerAddress(tokenId));
+
+            tokenName = token.name();
+            tokenSymbol = token.symbol();
+            tokenDecimals = token.decimals();
+            if (sameDistributor) distributor = token.distributor().toBytes();
+            operator = tokenManager.operator().toBytes();
+        }
+
+        _deployAndRegisterRemoteStandardizedToken(
+            salt,
+            tokenName,
+            tokenSymbol,
+            tokenDecimals,
+            distributor,
+            operator,
+            destinationChain,
+            gasValue
+        );
+    }
+
+    function _deployAndRegisterRemoteStandardizedToken(
+        bytes32 salt,
+        string memory tokenName,
+        string memory tokenSymbol,
+        uint8 tokenDecimals,
+        bytes memory distributor,
+        bytes memory operator,
+        string memory destinationChain,
+        uint256 gasValue
+    ) internal {
+        // slither-disable-next-line arbitrary-send-eth
+        service.deployAndRegisterRemoteStandardizedToken{ value: gasValue }(
+            salt,
+            tokenName,
+            tokenSymbol,
+            tokenDecimals,
+            distributor,
+            '',
+            0,
+            operator,
+            destinationChain,
+            gasValue
+        );
+    }
+}