across-protocol
diff --git a/‎contracts/SpokePool.sol‎
Lines changed: 602 additions & 222 deletions b/‎contracts/SpokePool.sol‎
Lines changed: 602 additions & 222 deletions
diff --git a/‎contracts/SpokePoolVerifier.sol‎
Lines changed: 9 additions & 7 deletions b/‎contracts/SpokePoolVerifier.sol‎
Lines changed: 9 additions & 7 deletions
diff --git a/‎contracts/SwapAndBridge.sol‎
Lines changed: 24 additions & 8 deletions b/‎contracts/SwapAndBridge.sol‎
Lines changed: 24 additions & 8 deletions
diff --git a/‎contracts/chain-adapters/Solana_Adapter.sol‎
Lines changed: 190 additions & 0 deletions b/‎contracts/chain-adapters/Solana_Adapter.sol‎
Lines changed: 190 additions & 0 deletions
@@ -3,6 +3,7 @@ pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/utils/Address.sol";
 import "./interfaces/V3SpokePoolInterface.sol";
+import { AddressToBytes32 } from "./libraries/AddressConverters.sol";
 
 /**
  * @notice SpokePoolVerifier is a contract that verifies that the SpokePool exists on this chain before sending ETH to it.
@@ -14,12 +15,13 @@ import "./interfaces/V3SpokePoolInterface.sol";
  */
 contract SpokePoolVerifier {
     using Address for address;
+    using AddressToBytes32 for address;
 
     error InvalidMsgValue();
     error InvalidSpokePool();
 
     /**
-     * @notice Passthrough function to `depositV3()` on the SpokePool contract.
+     * @notice Passthrough function to `deposit()` on the SpokePool contract.
      * @dev Protects the caller from losing their ETH (or other native token) by reverting if the SpokePool address
      * they intended to call does not exist on this chain. Because this contract can be deployed at the same address
      * everywhere callers should be protected even if the transaction is submitted to an unintended network.
@@ -42,12 +44,12 @@ contract SpokePoolVerifier {
      */
     function deposit(
         V3SpokePoolInterface spokePool,
-        address recipient,
-        address inputToken,
+        bytes32 recipient,
+        bytes32 inputToken,
         uint256 inputAmount,
         uint256 outputAmount,
         uint256 destinationChainId,
-        address exclusiveRelayer,
+        bytes32 exclusiveRelayer,
         uint32 quoteTimestamp,
         uint32 fillDeadline,
         uint32 exclusivityDeadline,
@@ -56,13 +58,13 @@ contract SpokePoolVerifier {
         if (msg.value != inputAmount) revert InvalidMsgValue();
         if (!address(spokePool).isContract()) revert InvalidSpokePool();
         // Set msg.sender as the depositor so that msg.sender can speed up the deposit.
-        spokePool.depositV3{ value: msg.value }(
-            msg.sender,
+        spokePool.deposit{ value: msg.value }(
+            msg.sender.toBytes32(),
             recipient,
             inputToken,
             // @dev Setting outputToken to 0x0 to instruct fillers to use the equivalent token
             // as the originToken on the destination chain.
-            address(0),
+            bytes32(0),
             inputAmount,
             outputAmount,
             destinationChainId,
 
@@ -6,6 +6,7 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "./Lockable.sol";
 import "@uma/core/contracts/common/implementation/MultiCaller.sol";
+import "./libraries/AddressConverters.sol";
 
 /**
  * @title SwapAndBridgeBase
@@ -14,6 +15,7 @@ import "@uma/core/contracts/common/implementation/MultiCaller.sol";
  */
 abstract contract SwapAndBridgeBase is Lockable, MultiCaller {
     using SafeERC20 for IERC20;
+    using AddressToBytes32 for address;
 
     // This contract performs a low level call with arbirary data to an external contract. This is a large attack
     // surface and we should whitelist which function selectors are allowed to be called on the exchange.
@@ -159,16 +161,30 @@ abstract contract SwapAndBridgeBase is Lockable, MultiCaller {
             depositData.outputAmount
         );
         // Deposit the swapped tokens into Across and bridge them using remainder of input params.
-        _acrossInputToken.safeIncreaseAllowance(address(SPOKE_POOL), returnAmount);
-        SPOKE_POOL.depositV3(
-            depositData.depositor,
-            depositData.recipient,
-            address(_acrossInputToken), // input token
-            depositData.outputToken, // output token
-            returnAmount, // input amount.
+        _depositV3(_acrossInputToken, returnAmount, depositData);
+    }
+
+    /**
+     * @notice Approves the spoke pool and calls `depositV3` function with the specified input parameters.
+     * @param _acrossInputToken Token to deposit into the spoke pool.
+     * @param _acrossInputAmount Amount of the input token to deposit into the spoke pool.
+     * @param depositData Specifies the Across deposit params to use.
+     */
+    function _depositV3(
+        IERC20 _acrossInputToken,
+        uint256 _acrossInputAmount,
+        DepositData calldata depositData
+    ) internal {
+        _acrossInputToken.safeIncreaseAllowance(address(SPOKE_POOL), _acrossInputAmount);
+        SPOKE_POOL.deposit(
+            depositData.depositor.toBytes32(),
+            depositData.recipient.toBytes32(),
+            address(_acrossInputToken).toBytes32(), // input token
+            depositData.outputToken.toBytes32(), // output token
+            _acrossInputAmount, // input amount.
             depositData.outputAmount, // output amount
             depositData.destinationChainid,
-            depositData.exclusiveRelayer,
+            depositData.exclusiveRelayer.toBytes32(),
             depositData.quoteTimestamp,
             depositData.fillDeadline,
             depositData.exclusivityDeadline,
 
@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import { IMessageTransmitter, ITokenMessenger } from "../external/interfaces/CCTPInterfaces.sol";
+import { SpokePoolInterface } from "../interfaces/SpokePoolInterface.sol";
+import { AdapterInterface } from "./interfaces/AdapterInterface.sol";
+import { CircleCCTPAdapter, CircleDomainIds } from "../libraries/CircleCCTPAdapter.sol";
+import { Bytes32ToAddress } from "../libraries/AddressConverters.sol";
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/**
+ * @notice Contract containing logic to send messages from L1 to Solana via CCTP.
+ * @dev Public functions calling external contracts do not guard against reentrancy because they are expected to be
+ * called via delegatecall, which will execute this contract's logic within the context of the originating contract.
+ * For example, the HubPool will delegatecall these functions, therefore it's only necessary that the HubPool's methods
+ * that call this contract's logic guard against reentrancy.
+ * @custom:security-contact bugs@across.to
+ */
+
+// solhint-disable-next-line contract-name-camelcase
+contract Solana_Adapter is AdapterInterface, CircleCCTPAdapter {
+    /**
+     * @notice We use Bytes32ToAddress library to map a Solana address to an Ethereum address representation.
+     * @dev The Ethereum address is derived from the Solana address by truncating it to its lowest 20 bytes. This same
+     * conversion must be done by the HubPool owner when adding Solana spoke pool and setting the corresponding pool
+     * rebalance and deposit routes.
+     */
+    using Bytes32ToAddress for bytes32;
+
+    /**
+     * @notice The official Circle CCTP MessageTransmitter contract endpoint.
+     * @dev Posted officially here: https://developers.circle.com/stablecoins/docs/evm-smart-contracts
+     */
+    // solhint-disable-next-line immutable-vars-naming
+    IMessageTransmitter public immutable cctpMessageTransmitter;
+
+    // Solana spoke pool address, decoded from Base58 to bytes32.
+    bytes32 public immutable SOLANA_SPOKE_POOL_BYTES32;
+
+    // Solana spoke pool address, mapped to its EVM address representation.
+    address public immutable SOLANA_SPOKE_POOL_ADDRESS;
+
+    // USDC mint address on Solana, decoded from Base58 to bytes32.
+    bytes32 public immutable SOLANA_USDC_BYTES32;
+
+    // USDC mint address on Solana, mapped to its EVM address representation.
+    address public immutable SOLANA_USDC_ADDRESS;
+
+    // USDC token address on Solana for the spoke pool (vault ATA), decoded from Base58 to bytes32.
+    bytes32 public immutable SOLANA_SPOKE_POOL_USDC_VAULT;
+
+    // Custom errors for constructor argument validation.
+    error InvalidCctpTokenMessenger(address tokenMessenger);
+    error InvalidCctpMessageTransmitter(address messageTransmitter);
+
+    // Custom errors for relayMessage validation.
+    error InvalidRelayMessageTarget(address target);
+    error InvalidOriginToken(address originToken);
+    error InvalidDestinationChainId(uint256 destinationChainId);
+
+    // Custom errors for relayTokens validation.
+    error InvalidL1Token(address l1Token);
+    error InvalidL2Token(address l2Token);
+    error InvalidAmount(uint256 amount);
+    error InvalidTokenRecipient(address to);
+
+    /**
+     * @notice Constructs new Adapter.
+     * @param _l1Usdc USDC address on L1.
+     * @param _cctpTokenMessenger TokenMessenger contract to bridge tokens via CCTP.
+     * @param _cctpMessageTransmitter MessageTransmitter contract to bridge messages via CCTP.
+     * @param solanaSpokePool Solana spoke pool address, decoded from Base58 to bytes32.
+     * @param solanaUsdc USDC mint address on Solana, decoded from Base58 to bytes32.
+     * @param solanaSpokePoolUsdcVault USDC token address on Solana for the spoke pool, decoded from Base58 to bytes32.
+     */
+    constructor(
+        IERC20 _l1Usdc,
+        ITokenMessenger _cctpTokenMessenger,
+        IMessageTransmitter _cctpMessageTransmitter,
+        bytes32 solanaSpokePool,
+        bytes32 solanaUsdc,
+        bytes32 solanaSpokePoolUsdcVault
+    ) CircleCCTPAdapter(_l1Usdc, _cctpTokenMessenger, CircleDomainIds.Solana) {
+        // Solana adapter requires CCTP TokenMessenger and MessageTransmitter contracts to be set.
+        if (address(_cctpTokenMessenger) == address(0)) {
+            revert InvalidCctpTokenMessenger(address(_cctpTokenMessenger));
+        }
+        if (address(_cctpMessageTransmitter) == address(0)) {
+            revert InvalidCctpMessageTransmitter(address(_cctpMessageTransmitter));
+        }
+
+        cctpMessageTransmitter = _cctpMessageTransmitter;
+
+        SOLANA_SPOKE_POOL_BYTES32 = solanaSpokePool;
+        SOLANA_SPOKE_POOL_ADDRESS = solanaSpokePool.toAddressUnchecked();
+
+        SOLANA_USDC_BYTES32 = solanaUsdc;
+        SOLANA_USDC_ADDRESS = solanaUsdc.toAddressUnchecked();
+
+        SOLANA_SPOKE_POOL_USDC_VAULT = solanaSpokePoolUsdcVault;
+    }
+
+    /**
+     * @notice Send cross-chain message to target on Solana.
+     * @dev Only allows sending messages to the Solana spoke pool.
+     * @param target Program on Solana (translated as EVM address) that will receive message.
+     * @param message Data to send to target.
+     */
+    function relayMessage(address target, bytes calldata message) external payable override {
+        if (target != SOLANA_SPOKE_POOL_ADDRESS) {
+            revert InvalidRelayMessageTarget(target);
+        }
+
+        bytes4 selector = bytes4(message[:4]);
+        if (selector == SpokePoolInterface.setEnableRoute.selector) {
+            cctpMessageTransmitter.sendMessage(
+                CircleDomainIds.Solana,
+                SOLANA_SPOKE_POOL_BYTES32,
+                _translateSetEnableRoute(message)
+            );
+        } else {
+            cctpMessageTransmitter.sendMessage(CircleDomainIds.Solana, SOLANA_SPOKE_POOL_BYTES32, message);
+        }
+
+        // TODO: consider if we need also to emit the translated message.
+        emit MessageRelayed(target, message);
+    }
+
+    /**
+     * @notice Bridge tokens to Solana.
+     * @dev Only allows bridging USDC to Solana spoke pool.
+     * @param l1Token L1 token to deposit.
+     * @param l2Token L2 token to receive.
+     * @param amount Amount of L1 tokens to deposit and L2 tokens to receive.
+     * @param to Bridge recipient.
+     */
+    function relayTokens(
+        address l1Token,
+        address l2Token,
+        uint256 amount,
+        address to
+    ) external payable override {
+        if (l1Token != address(usdcToken)) {
+            revert InvalidL1Token(l1Token);
+        }
+        if (l2Token != SOLANA_USDC_ADDRESS) {
+            revert InvalidL2Token(l2Token);
+        }
+        if (amount > type(uint64).max) {
+            revert InvalidAmount(amount);
+        }
+        if (to != SOLANA_SPOKE_POOL_ADDRESS) {
+            revert InvalidTokenRecipient(to);
+        }
+
+        _transferUsdc(SOLANA_SPOKE_POOL_USDC_VAULT, amount);
+
+        // TODO: consider if we need also to emit the translated addresses.
+        emit TokensRelayed(l1Token, l2Token, amount, to);
+    }
+
+    /**
+     * @notice Translates a message to enable/disable a route on Solana spoke pool.
+     * @param message Message to translate, expecting setEnableRoute(address,uint256,bool).
+     * @return Translated message, using setEnableRoute(bytes32,uint64,bool).
+     */
+    function _translateSetEnableRoute(bytes calldata message) internal view returns (bytes memory) {
+        (address originToken, uint256 destinationChainId, bool enable) = abi.decode(
+            message[4:],
+            (address, uint256, bool)
+        );
+
+        if (originToken != SOLANA_USDC_ADDRESS) {
+            revert InvalidOriginToken(originToken);
+        }
+
+        if (destinationChainId > type(uint64).max) {
+            revert InvalidDestinationChainId(destinationChainId);
+        }
+
+        return
+            abi.encodeWithSignature(
+                "setEnableRoute(bytes32,uint64,bool)",
+                SOLANA_USDC_BYTES32,
+                uint64(destinationChainId),
+                enable
+            );
+    }
+}