Wormhole

1/ contracts/Bridge.sol
2// SPDX-License-Identifier: Apache 2
3
4pragma solidity ^0.8.0;
5
6import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
7import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
8import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
9
10import "../libraries/external/BytesLib.sol";
11
12import "./BridgeGetters.sol";
13import "./BridgeSetters.sol";
14import "./BridgeStructs.sol";
15import "./BridgeGovernance.sol";
16
17import "./token/Token.sol";
18import "./token/TokenImplementation.sol";
19
20contract Bridge is BridgeGovernance, ReentrancyGuard {
21    using BytesLib for bytes;
22
23    /*
24     *  @dev Produce a AssetMeta message for a given token
25     */
26    function attestToken(address tokenAddress, uint32 nonce) public payable returns (uint64 sequence) {
27        // decimals, symbol & token are not part of the core ERC20 token standard, so we need to support contracts that dont implement them
28        (,bytes memory queriedDecimals) = tokenAddress.staticcall(abi.encodeWithSignature("decimals()"));
29        (,bytes memory queriedSymbol) = tokenAddress.staticcall(abi.encodeWithSignature("symbol()"));
30        (,bytes memory queriedName) = tokenAddress.staticcall(abi.encodeWithSignature("name()"));
31
32        uint8 decimals = abi.decode(queriedDecimals, (uint8));
33
34        string memory symbolString = abi.decode(queriedSymbol, (string));
35        string memory nameString = abi.decode(queriedName, (string));
36
37        bytes32 symbol;
38        bytes32 name;
39        assembly {
40            // first 32 bytes hold string length
41            symbol := mload(add(symbolString, 32))
42            name := mload(add(nameString, 32))
43        }
44
45        BridgeStructs.AssetMeta memory meta = BridgeStructs.AssetMeta({
46        payloadID : 2,
47        tokenAddress : bytes32(uint256(uint160(tokenAddress))), // Address of the token. Left-zero-padded if shorter than 32 bytes
48        tokenChain : chainId(), // Chain ID of the token
49        decimals : decimals, // Number of decimals of the token (big-endian uint8)
50        symbol : symbol, // Symbol of the token (UTF-8)
51        name : name // Name of the token (UTF-8)
52        });
53
54        bytes memory encoded = encodeAssetMeta(meta);
55
56        sequence = wormhole().publishMessage{
57            value : msg.value
58        }(nonce, encoded, finality());
59    }
60
61    /*
62     *  @notice Send eth through portal by first wrapping it to WETH.
63     */
64    function wrapAndTransferETH(
65        uint16 recipientChain,
66        bytes32 recipient,
67        uint256 arbiterFee,
68        uint32 nonce
69    ) public payable returns (uint64 sequence) {
70        BridgeStructs.TransferResult
71            memory transferResult = _wrapAndTransferETH(arbiterFee);
72        sequence = logTransfer(
73            transferResult.tokenChain,
74            transferResult.tokenAddress,
75            transferResult.normalizedAmount,
76            recipientChain,
77            recipient,
78            transferResult.normalizedArbiterFee,
79            transferResult.wormholeFee,
80            nonce
81        );
82    }
83
84    /*
85     *  @notice Send eth through portal by first wrapping it.
86     *
87     *  @dev This type of transfer is called a "contract-controlled transfer".
88     *  There are three differences from a regular token transfer:
89     *  1) Additional arbitrary payload can be attached to the message
90     *  2) Only the recipient (typically a contract) can redeem the transaction
91     *  3) The sender's address (msg.sender) is also included in the transaction payload
92     *
93     *  With these three additional components, xDapps can implement cross-chain
94     *  composable interactions.
95     */
96    function wrapAndTransferETHWithPayload(
97        uint16 recipientChain,
98        bytes32 recipient,
99        uint32 nonce,
100        bytes memory payload
101    ) public payable returns (uint64 sequence) {
102        BridgeStructs.TransferResult
103            memory transferResult = _wrapAndTransferETH(0);
104        sequence = logTransferWithPayload(
105            transferResult.tokenChain,
106            transferResult.tokenAddress,
107            transferResult.normalizedAmount,
108            recipientChain,
109            recipient,
110            transferResult.wormholeFee,
111            nonce,
112            payload
113        );
114    }
115
116    function _wrapAndTransferETH(uint256 arbiterFee) internal returns (BridgeStructs.TransferResult memory transferResult) {
117        uint wormholeFee = wormhole().messageFee();
118
119        require(wormholeFee < msg.value, "value is smaller than wormhole fee");
120
121        uint amount = msg.value - wormholeFee;
122
123        require(arbiterFee <= amount, "fee is bigger than amount minus wormhole fee");
124
125        uint normalizedAmount = normalizeAmount(amount, 18);
126        uint normalizedArbiterFee = normalizeAmount(arbiterFee, 18);
127
128        // refund dust
129        uint dust = amount - deNormalizeAmount(normalizedAmount, 18);
130        if (dust > 0) {
131            payable(msg.sender).transfer(dust);
132        }
133
134        // deposit into WETH
135        WETH().deposit{
136            value : amount - dust
137        }();
138
139        // track and check outstanding token amounts
140        bridgeOut(address(WETH()), normalizedAmount);
141
142        transferResult = BridgeStructs.TransferResult({
143            tokenChain : chainId(),
144            tokenAddress : bytes32(uint256(uint160(address(WETH())))),
145            normalizedAmount : normalizedAmount,
146            normalizedArbiterFee : normalizedArbiterFee,
147            wormholeFee : wormholeFee
148        });
149    }
150
151    /*
152     *  @notice Send ERC20 token through portal.
153     */
154    function transferTokens(
155        address token,
156        uint256 amount,
157        uint16 recipientChain,
158        bytes32 recipient,
159        uint256 arbiterFee,
160        uint32 nonce
161    ) public payable nonReentrant returns (uint64 sequence) {
162        BridgeStructs.TransferResult memory transferResult = _transferTokens(
163            token,
164            amount,
165            arbiterFee
166        );
167        sequence = logTransfer(
168            transferResult.tokenChain,
169            transferResult.tokenAddress,

JavaScript Tests