Asset from polkadot

contracts/src/AgentExecutor.sol

@@ -2,29 +2,20 @@
 // SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
 pragma solidity 0.8.23;
 
-import {AgentExecuteCommand, ParaID} from "./Types.sol";
+import {ParaID} from "./Types.sol";
 import {SubstrateTypes} from "./SubstrateTypes.sol";
 
 import {IERC20} from "./interfaces/IERC20.sol";
 import {SafeTokenTransfer, SafeNativeTransfer} from "./utils/SafeTransfer.sol";
+import {ERC20} from "./ERC20.sol";
+import {Gateway} from "./Gateway.sol";
 
 /// @title Code which will run within an `Agent` using `delegatecall`.
 /// @dev This is a singleton contract, meaning that all agents will execute the same code.
 contract AgentExecutor {
     using SafeTokenTransfer for IERC20;
     using SafeNativeTransfer for address payable;
 
-    /// @dev Execute a message which originated from the Polkadot side of the bridge. In other terms,
-    /// the `data` parameter is constructed by the BridgeHub parachain.
-    ///
-    function execute(bytes memory data) external {
-        (AgentExecuteCommand command, bytes memory params) = abi.decode(data, (AgentExecuteCommand, bytes));
-        if (command == AgentExecuteCommand.TransferToken) {
-            (address token, address recipient, uint128 amount) = abi.decode(params, (address, address, uint128));
-            _transferToken(token, recipient, amount);
-        }
-    }
-
     /// @dev Transfer ether to `recipient`. Unlike `_transferToken` This logic is not nested within `execute`,
     /// as the gateway needs to control an agent's ether balance directly.
     ///
@@ -33,7 +24,16 @@ contract AgentExecutor {
     }
 
     /// @dev Transfer ERC20 to `recipient`. Only callable via `execute`.
-    function _transferToken(address token, address recipient, uint128 amount) internal {
+    function transferToken(address token, address recipient, uint128 amount) external {
         IERC20(token).safeTransfer(recipient, amount);
     }
+
+    /// @dev Mint ERC20 token to `recipient`.
+    function mintToken(address token, address recipient, uint256 amount) external {
+        ERC20(token).mint(recipient, amount);
+    }
+
+    function burnToken(address token, address sender, uint256 amount) external {
+        ERC20(token).burn(sender, amount);
+    }
 }

contracts/src/Assets.sol

@@ -8,9 +8,15 @@ import {IGateway} from "./interfaces/IGateway.sol";
 import {SafeTokenTransferFrom} from "./utils/SafeTransfer.sol";
 
 import {AssetsStorage, TokenInfo} from "./storage/AssetsStorage.sol";
+import {CoreStorage} from "./storage/CoreStorage.sol";
+
 import {SubstrateTypes} from "./SubstrateTypes.sol";
 import {ParaID, MultiAddress, Ticket, Costs} from "./Types.sol";
 import {Address} from "./utils/Address.sol";
+import {AgentExecutor} from "./AgentExecutor.sol";
+import {Agent} from "./Agent.sol";
+import {Call} from "./utils/Call.sol";
+import {ERC20} from "./ERC20.sol";
 
 /// @title Library for implementing Ethereum->Polkadot ERC20 transfers.
 library Assets {
@@ -24,6 +30,10 @@ library Assets {
     error TokenNotRegistered();
     error Unsupported();
     error InvalidDestinationFee();
+    error AgentDoesNotExist();
+    error TokenAlreadyRegistered();
+    error TokenMintFailed();
+    error TokenTransferFailed();
 
     function isTokenRegistered(address token) external view returns (bool) {
         return AssetsStorage.layout().tokenRegistry[token].isRegistered;
@@ -83,11 +93,6 @@ library Assets {
     ) external returns (Ticket memory ticket) {
         AssetsStorage.Layout storage $ = AssetsStorage.layout();
 
-        TokenInfo storage info = $.tokenRegistry[token];
-        if (!info.isRegistered) {
-            revert TokenNotRegistered();
-        }
-
         // Lock the funds into AssetHub's agent contract
         _transferToAgent($.assetHubAgent, token, sender, amount);
 
@@ -174,4 +179,111 @@ library Assets {
 
         emit IGateway.TokenRegistrationSent(token);
     }
+
+    // @dev Transfer polkadot native tokens back
+    function sendForeignToken(
+        address agent,
+        address executor,
+        TokenInfo storage info,
+        address sender,
+        ParaID destinationChain,
+        MultiAddress calldata destinationAddress,
+        uint128 destinationChainFee,
+        uint128 amount
+    ) external returns (Ticket memory ticket) {
+        if (destinationChainFee == 0) {
+            revert InvalidDestinationFee();
+        }
+        // Polkadot-native token: burn wrapped token
+        _burnToken(executor, agent, info.token, sender, amount);
+
+        ticket.dest = destinationChain;
+        ticket.costs = _sendForeignTokenCosts(destinationChainFee);
+
+        if (destinationAddress.isAddress32()) {
+            // The receiver has a 32-byte account ID
+            ticket.payload = SubstrateTypes.SendForeignTokenToAddress32(
+                info.tokenID, destinationChain, destinationAddress.asAddress32(), destinationChainFee, amount
+            );
+        } else if (destinationAddress.isAddress20()) {
+            // The receiver has a 20-byte account ID
+            ticket.payload = SubstrateTypes.SendForeignTokenToAddress20(
+                info.tokenID, destinationChain, destinationAddress.asAddress20(), destinationChainFee, amount
+            );
+        } else {
+            revert Unsupported();
+        }
+
+        emit IGateway.TokenSent(info.token, sender, destinationChain, destinationAddress, amount);
+    }
+
+    function _burnToken(address agentExecutor, address agent, address token, address sender, uint256 amount) internal {
+        bytes memory call = abi.encodeCall(AgentExecutor.burnToken, (token, sender, amount));
+        (bool success, bytes memory returndata) = (Agent(payable(agent)).invoke(agentExecutor, call));
+        Call.verifyResult(success, returndata);
+    }
+
+    function _sendForeignTokenCosts(uint128 destinationChainFee) internal pure returns (Costs memory costs) {
+        costs.foreign = destinationChainFee;
+        costs.native = 0;
+    }
+
+    // @dev Register a new fungible Polkadot token for an agent
+    function registerForeignToken(
+        bytes32 agentID,
+        address agent,
+        bytes32 tokenID,
+        string memory name,
+        string memory symbol,
+        uint8 decimals
+    ) external {
+        AssetsStorage.Layout storage $ = AssetsStorage.layout();
+        if ($.tokenRegistryByID[tokenID].isRegistered == true) {
+            revert TokenAlreadyRegistered();
+        }
+        ERC20 foreignToken = new ERC20(agent, name, symbol, decimals);
+        address token = address(foreignToken);
+        TokenInfo memory info =
+            TokenInfo({isRegistered: true, isForeign: true, tokenID: tokenID, agentID: agentID, token: token});
+        $.tokenRegistry[token] = info;
+        $.tokenRegistryByID[tokenID] = info;
+        emit IGateway.ForeignTokenRegistered(tokenID, agentID, token);
+    }
+
+    // @dev Mint foreign token from Polkadot
+    function mintForeignToken(address executor, address agent, bytes32 tokenID, address recipient, uint256 amount)
+        external
+    {
+        address token = _tokenAddressOf(tokenID);
+        bytes memory call = abi.encodeCall(AgentExecutor.mintToken, (token, recipient, amount));
+        (bool success,) = Agent(payable(agent)).invoke(executor, call);
+        if (!success) {
+            revert TokenMintFailed();
+        }
+    }
+
+    // @dev Transfer ERC20 to `recipient`
+    function transferToken(address executor, address agent, address token, address recipient, uint128 amount)
+        external
+    {
+        bytes memory call = abi.encodeCall(AgentExecutor.transferToken, (token, recipient, amount));
+        (bool success,) = Agent(payable(agent)).invoke(executor, call);
+        if (!success) {
+            revert TokenTransferFailed();
+        }
+    }
+
+    // @dev Get token address by tokenID
+    function tokenAddressOf(bytes32 tokenID) external view returns (address) {
+        return _tokenAddressOf(tokenID);
+    }
+
+    // @dev Get token address by tokenID
+    function _tokenAddressOf(bytes32 tokenID) internal view returns (address) {
+        AssetsStorage.Layout storage $ = AssetsStorage.layout();
+        if ($.tokenRegistryByID[tokenID].isRegistered == false) {
+            revert TokenNotRegistered();
+        }
+        return $.tokenRegistryByID[tokenID].token;
+    }
 }

contracts/src/ERC20.sol

@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2023 Axelar Network
+// SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
+
+pragma solidity 0.8.23;
+
+import {IERC20} from "./interfaces/IERC20.sol";
+import {IERC20Permit} from "./interfaces/IERC20Permit.sol";
+import {ERC20Lib} from "./ERC20Lib.sol";
+
+/**
+ * @dev Implementation of the {IERC20} interface.
+ *
+ * This implementation is agnostic to the way tokens are created. This means
+ * that a supply mechanism has to be added in a derived contract using {_mint}.
+ * This supply mechanism has been added in {ERC20Permit-mint}.
+ *
+ * We have followed general OpenZeppelin guidelines: functions revert instead
+ * of returning `false` on failure. This behavior is conventional and does
+ * not conflict with the expectations of ERC20 applications.
+ *
+ * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
+ * This allows applications to reconstruct the allowance for all accounts just
+ * by listening to these events. Other implementations of the EIP may not emit
+ * these events, as it isn't required by the specification.
+ *
+ * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
+ * functions have been added to mitigate the well-known issues around setting
+ * allowances. See {IERC20-approve}.
+ */
+contract ERC20 is IERC20, IERC20Permit {
+    using ERC20Lib for ERC20Lib.TokenStorage;
+
+    error Unauthorized();
+
+    ERC20Lib.TokenStorage token;
+
+    address public immutable OWNER;
+
+    uint8 public immutable decimals;
+
+    string public name;
+    string public symbol;
+
+    /**
+     * @dev Sets the values for {name}, {symbol}, and {decimals}.
+     */
+    constructor(address _owner, string memory name_, string memory symbol_, uint8 decimals_) {
+        OWNER = _owner;
+        name = name_;
+        symbol = symbol_;
+        decimals = decimals_;
+        token.init(name_);
+    }
+
+    modifier onlyOwner() {
+        if (msg.sender != OWNER) {
+            revert Unauthorized();
+        }
+        _;
+    }
+
+    /**
+     * @dev Creates `amount` tokens and assigns them to `account`, increasing
+     * the total supply. Can only be called by the owner.
+     *
+     * Emits a {Transfer} event with `from` set to the zero address.
+     *
+     * Requirements:
+     *
+     * - `account` cannot be the zero address.
+     */
+    function mint(address account, uint256 amount) external virtual onlyOwner {
+        token.mint(account, amount);
+    }
+
+    /**
+     * @dev Destroys `amount` tokens from the account.
+     */
+    function burn(address account, uint256 amount) external virtual onlyOwner {
+        token.burn(account, amount);
+    }
+
+    /**
+     * @dev See {IERC20-transfer}.
+     *
+     * Requirements:
+     *
+     * - `recipient` cannot be the zero address.
+     * - the caller must have a balance of at least `amount`.
+     */
+    function transfer(address recipient, uint256 amount) external virtual override returns (bool) {
+        return token.transfer(msg.sender, recipient, amount);
+    }
+
+    /**
+     * @dev See {IERC20-approve}.
+     *
+     * NOTE: Prefer the {increaseAllowance} and {decreaseAllowance} methods, as
+     * they aren't vulnerable to the frontrunning attack described here:
+     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+     * See {IERC20-approve}.
+     *
+     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
+     * `transferFrom`. This is semantically equivalent to an infinite approval.
+     *
+     * Requirements:
+     *
+     * - `spender` cannot be the zero address.
+     */
+    function approve(address spender, uint256 amount) external virtual override returns (bool) {
+        return token.approve(msg.sender, spender, amount);
+    }
+
+    /**
+     * @dev See {IERC20-transferFrom}.
+     *
+     * Emits an {Approval} event indicating the updated allowance. This is not
+     * required by the EIP. See the note at the beginning of {ERC20}.
+     *
+     * Requirements:
+     *
+     * - `sender` and `recipient` cannot be the zero address.
+     * - `sender` must have a balance of at least `amount`.
+     * - the caller must have allowance for ``sender``'s tokens of at least
+     * `amount`.
+     */
+    function transferFrom(address sender, address recipient, uint256 amount) external virtual override returns (bool) {
+        return token.transferFrom(sender, recipient, amount);
+    }
+
+    /**
+     * @dev Atomically increases the allowance granted to `spender` by the caller.
+     *
+     * This is an alternative to {approve} that can be used as a mitigation for
+     * problems described in {IERC20-approve}.
+     *
+     * Emits an {Approval} event indicating the updated allowance.
+     *
+     * Requirements:
+     *
+     * - `spender` cannot be the zero address.
+     */
+    function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
+        return token.increaseAllowance(spender, addedValue);
+    }
+
+    /**
+     * @dev Atomically decreases the allowance granted to `spender` by the caller.
+     *
+     * This is an alternative to {approve} that can be used as a mitigation for
+     * problems described in {IERC20-approve}.
+     *
+     * Emits an {Approval} event indicating the updated allowance.
+     *
+     * Requirements:
+     *
+     * - `spender` cannot be the zero address.
+     * - `spender` must have allowance for the caller of at least
+     * `subtractedValue`.
+     */
+    function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
+        return token.decreaseAllowance(spender, subtractedValue);
+    }
+
+    function permit(address issuer, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
+        external
+    {
+        token.permit(issuer, spender, value, deadline, v, r, s);
+    }
+
+    function balanceOf(address account) external view returns (uint256) {
+        return token.balancesOf(account);
+    }
+
+    function nonces(address account) external view returns (uint256) {
+        return token.noncesOf(account);
+    }
+
+    function totalSupply() external view returns (uint256) {
+        return token.totalSupplyOf();
+    }
+
+    function allowance(address owner, address spender) external view returns (uint256) {
+        return token.allowanceOf(owner, spender);
+    }
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32) {
+        return token.domainSeparatorOf();
+    }
+}