@bananapus/suckers-v6 0.0.1

package/src/deployers/JBSuckerDeployer.sol

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
+import {IJBTokens} from "@bananapus/core-v6/src/interfaces/IJBTokens.sol";
+import {IJBSuckerDeployer} from "./../interfaces/IJBSuckerDeployer.sol";
+import {IJBSucker} from "./../interfaces/IJBSucker.sol";
+
+import {JBPermissioned} from "@bananapus/core-v6/src/abstract/JBPermissioned.sol";
+import {LibClone} from "solady/src/utils/LibClone.sol";
+import {JBSucker} from "../JBSucker.sol";
+import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
+import {Context} from "@openzeppelin/contracts/utils/Context.sol";
+
+/// @notice A base implementation for deploying suckers.
+abstract contract JBSuckerDeployer is ERC2771Context, JBPermissioned, IJBSuckerDeployer {
+    //*********************************************************************//
+    // --------------- public immutable stored properties ---------------- //
+    //*********************************************************************//
+
+    /// @notice The directory of terminals and controllers for projects.
+    IJBDirectory public immutable override DIRECTORY;
+
+    /// @notice Only this address can configure this deployer, can only be used once.
+    address public immutable override LAYER_SPECIFIC_CONFIGURATOR;
+
+    /// @notice The contract that manages token minting and burning.
+    IJBTokens public immutable override TOKENS;
+
+    //*********************************************************************//
+    // ---------------------- public stored properties ------------------- //
+    //*********************************************************************//
+
+    /// @notice A mapping of suckers deployed by this contract.
+    mapping(address => bool) public override isSucker;
+
+    /// @notice The singleton used to clone suckers.
+    JBSucker public singleton;
+
+    //*********************************************************************//
+    // ---------------------------- constructor -------------------------- //
+    //*********************************************************************//
+
+    /// @param directory The directory of terminals and controllers for projects.
+    /// @param permissions The permissions contract for the deployer.
+    /// @param tokens The contract that manages token minting and burning.
+    /// @param configurator The address of the configurator.
+    constructor(
+        IJBDirectory directory,
+        IJBPermissions permissions,
+        IJBTokens tokens,
+        address configurator,
+        address trustedForwarder
+    )
+        ERC2771Context(trustedForwarder)
+        JBPermissioned(permissions)
+    {
+        DIRECTORY = directory;
+        TOKENS = tokens;
+        LAYER_SPECIFIC_CONFIGURATOR = configurator;
+
+        // There has to be a configurator address or the layer specific configuration has to already be configured.
+        if (configurator == address(0) && !_layerSpecificConfigurationIsSet()) {
+            revert JBSuckerDeployer_ZeroConfiguratorAddress();
+        }
+    }
+
+    //*********************************************************************//
+    // ------------------------ internal views --------------------------- //
+    //*********************************************************************//
+
+    /// @notice Check if the layer specific configuration is set or not. Used as a sanity check.
+    function _layerSpecificConfigurationIsSet() internal view virtual returns (bool);
+
+    /// @notice The message's sender. Preferred to use over `msg.sender`.
+    /// @return sender The address which sent this call.
+    function _msgSender() internal view override(ERC2771Context, Context) returns (address sender) {
+        return ERC2771Context._msgSender();
+    }
+
+    /// @notice The calldata. Preferred to use over `msg.data`.
+    /// @return calldata The `msg.data` of this call.
+    function _msgData() internal view override(ERC2771Context, Context) returns (bytes calldata) {
+        return ERC2771Context._msgData();
+    }
+
+    /// @dev ERC-2771 specifies the context as being a single address (20 bytes).
+    function _contextSuffixLength() internal view virtual override(ERC2771Context, Context) returns (uint256) {
+        return ERC2771Context._contextSuffixLength();
+    }
+
+    //*********************************************************************//
+    // --------------------- external transactions ----------------------- //
+    //*********************************************************************//
+
+    /// @notice Configure the singleton instance that is used to clone suckers.
+    /// @dev Can only be called *once* by the layer specific configurator.
+    /// @param _singleton The address of the singleton.
+    function configureSingleton(JBSucker _singleton) external {
+        // Make sure only the configurator can call this function.
+        if (_msgSender() != LAYER_SPECIFIC_CONFIGURATOR) {
+            revert JBSuckerDeployer_Unauthorized(_msgSender(), LAYER_SPECIFIC_CONFIGURATOR);
+        }
+
+        // Ensure that the layer specific configuration is set.
+        if (!_layerSpecificConfigurationIsSet()) {
+            revert JBSuckerDeployer_LayerSpecificNotConfigured();
+        }
+
+        // Make sure the singleton is not already configured.
+        if (address(singleton) != address(0)) revert JBSuckerDeployer_AlreadyConfigured();
+
+        singleton = _singleton;
+    }
+
+    /// @notice Create a new `JBSucker` for a specific project.
+    /// @dev Uses the sender address as the salt, which means the same sender must call this function on both chains.
+    /// @param localProjectId The project's ID on the local chain.
+    /// @param salt The salt to use for the `create2` address.
+    /// @return sucker The address of the new sucker.
+    function createForSender(
+        uint256 localProjectId,
+        bytes32 salt
+    )
+        external
+        override(IJBSuckerDeployer)
+        returns (IJBSucker sucker)
+    {
+        // Make sure that this deployer is configured properly.
+        if (address(singleton) == address(0)) {
+            revert JBSuckerDeployer_DeployerIsNotConfigured();
+        }
+
+        // Hash the salt with the sender address to ensure only a specific sender can create this sucker.
+        salt = keccak256(abi.encodePacked(_msgSender(), salt));
+
+        // Clone the singleton.
+        sucker = IJBSucker(LibClone.cloneDeterministic(address(singleton), salt));
+
+        // Mark it as a sucker that was deployed by this deployer.
+        isSucker[address(sucker)] = true;
+
+        // Initialize the clone.
+        JBSucker(payable(address(sucker))).initialize(localProjectId);
+    }
+}

package/src/enums/JBAddToBalanceMode.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice Options for how a `JBSucker`'s `amountToAddToBalance` gets added to its project's balance.
+/// @custom:element MANUAL The amount gets added to the project's balance manually by calling
+/// `addOutstandingAmountToBalance`.
+/// @custom:element ON_CLAIM The amount gets added to the project's balance automatically when `claim` is called.
+enum JBAddToBalanceMode {
+    MANUAL,
+    ON_CLAIM
+}

package/src/enums/JBLayer.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice Whether a `JBArbitrumSucker` is on L1 or L2.
+enum JBLayer {
+    L1,
+    L2
+}

package/src/enums/JBSuckerState.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice Options for the deprecation state of a `JBSucker`.
+/// @custom:member ENABLED The `JBSucker` is not deprecated.
+/// @custom:member DEPRECATION_PENDING The `JBSucker` has a deprecation set, but it is still fully functional.
+/// @custom:member SENDING_DISABLED The `JBSucker` is deprecated and sending to the pair sucker is disabled.
+/// @custom:member DEPRECATED The `JBSucker` is deprecated, but it continues to let users claim their funds.
+enum JBSuckerState {
+    ENABLED,
+    DEPRECATION_PENDING,
+    SENDING_DISABLED,
+    DEPRECATED
+}

package/src/interfaces/IArbGatewayRouter.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @title Common interface for L1 and L2 Gateway Routers
+ */
+interface IArbGatewayRouter {
+    function defaultGateway() external view returns (address gateway);
+
+    function getGateway(address _token) external view returns (address gateway);
+}

package/src/interfaces/IArbL1GatewayRouter.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IArbL1GatewayRouter {
+    function outboundTransferCustomRefund(
+        address token,
+        address refundTo,
+        address to,
+        uint256 amount,
+        uint256 maxGas,
+        uint256 gasPriceBid,
+        bytes calldata data
+    )
+        external
+        payable
+        returns (bytes memory);
+}

package/src/interfaces/IArbL2GatewayRouter.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IArbL2GatewayRouter {
+    function outboundTransfer(
+        address l1Token,
+        address to,
+        uint256 amount,
+        bytes calldata data
+    )
+        external
+        payable
+        returns (bytes memory);
+}

package/src/interfaces/ICCIPRouter.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IRouterClient} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
+import {IWrappedNativeToken} from "./IWrappedNativeToken.sol";
+
+// https://github.com/smartcontractkit/ccip/blob/ccip-develop/contracts/src/v0.8/ccip/applications/EtherSenderReceiver.sol
+
+interface ICCIPRouter is IRouterClient {
+    function getWrappedNative() external view returns (IWrappedNativeToken);
+}

package/src/interfaces/IJBArbitrumSucker.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IInbox} from "@arbitrum/nitro-contracts/src/bridge/IInbox.sol";
+
+import {IArbGatewayRouter} from "./IArbGatewayRouter.sol";
+import {JBLayer} from "./../enums/JBLayer.sol";
+
+interface IJBArbitrumSucker {
+    function ARBINBOX() external view returns (IInbox);
+    function GATEWAYROUTER() external view returns (IArbGatewayRouter);
+    function LAYER() external view returns (JBLayer);
+}

package/src/interfaces/IJBArbitrumSuckerDeployer.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBLayer} from "../enums/JBLayer.sol";
+import {IArbGatewayRouter} from "../interfaces/IArbGatewayRouter.sol";
+import {IInbox} from "@arbitrum/nitro-contracts/src/bridge/IInbox.sol";
+
+interface IJBArbitrumSuckerDeployer {
+    function arbGatewayRouter() external view returns (IArbGatewayRouter);
+    function arbInbox() external view returns (IInbox);
+    function arbLayer() external view returns (JBLayer);
+}

package/src/interfaces/IJBCCIPSuckerDeployer.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBSucker} from "./IJBSucker.sol";
+import {ICCIPRouter} from "./ICCIPRouter.sol";
+
+interface IJBCCIPSuckerDeployer {
+    event CCIPConstantsSet(
+        address ccipRouter, uint256 ccipRemoteChainId, uint64 ccipRemoteChainSelector, address caller
+    );
+
+    function ccipRouter() external view returns (ICCIPRouter);
+    function ccipRemoteChainId() external view returns (uint256);
+    function ccipRemoteChainSelector() external view returns (uint64);
+}

package/src/interfaces/IJBOpSuckerDeployer.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IOPStandardBridge} from "./IOPStandardBridge.sol";
+import {IOPMessenger} from "./IOPMessenger.sol";
+
+interface IJBOpSuckerDeployer {
+    function opBridge() external view returns (IOPStandardBridge);
+    function opMessenger() external view returns (IOPMessenger);
+    function setChainSpecificConstants(IOPMessenger messenger, IOPStandardBridge bridge) external;
+}

package/src/interfaces/IJBOptimismSucker.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IOPMessenger} from "./IOPMessenger.sol";
+import {IOPStandardBridge} from "./IOPStandardBridge.sol";
+
+interface IJBOptimismSucker {
+    function OPBRIDGE() external view returns (IOPStandardBridge);
+    function OPMESSENGER() external view returns (IOPMessenger);
+}

package/src/interfaces/IJBSucker.sol

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.sol";
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBTokens} from "@bananapus/core-v6/src/interfaces/IJBTokens.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {JBAddToBalanceMode} from "../enums/JBAddToBalanceMode.sol";
+import {JBSuckerState} from "../enums/JBSuckerState.sol";
+import {JBClaim} from "../structs/JBClaim.sol";
+import {JBInboxTreeRoot} from "../structs/JBInboxTreeRoot.sol";
+import {JBOutboxTree} from "../structs/JBOutboxTree.sol";
+import {JBRemoteToken} from "../structs/JBRemoteToken.sol";
+import {JBTokenMapping} from "../structs/JBTokenMapping.sol";
+import {JBMessageRoot} from "../structs/JBMessageRoot.sol";
+
+/// @notice The minimal interface for a sucker contract.
+interface IJBSucker is IERC165 {
+    event Claimed(
+        bytes32 beneficiary,
+        address token,
+        uint256 projectTokenCount,
+        uint256 terminalTokenAmount,
+        uint256 index,
+        bool autoAddedToBalance,
+        address caller
+    );
+    event InsertToOutboxTree(
+        bytes32 indexed beneficiary,
+        address indexed token,
+        bytes32 hashed,
+        uint256 index,
+        bytes32 root,
+        uint256 projectTokenCount,
+        uint256 terminalTokenAmount,
+        address caller
+    );
+    event NewInboxTreeRoot(address indexed token, uint64 nonce, bytes32 root, address caller);
+    event RootToRemote(bytes32 indexed root, address indexed token, uint256 index, uint64 nonce, address caller);
+    event StaleRootRejected(address indexed token, uint64 receivedNonce, uint64 currentNonce);
+
+    /// @notice The minimum gas required for a basic cross-chain call.
+    /// @return The base gas limit.
+    function MESSENGER_BASE_GAS_LIMIT() external view returns (uint32);
+
+    /// @notice The minimum gas required for bridging ERC-20 tokens.
+    /// @return The ERC-20 minimum gas limit.
+    function MESSENGER_ERC20_MIN_GAS_LIMIT() external view returns (uint32);
+
+    /// @notice The mode used when adding reclaimed tokens to the project's balance.
+    /// @return The add-to-balance mode.
+    function ADD_TO_BALANCE_MODE() external view returns (JBAddToBalanceMode);
+
+    /// @notice The directory of terminals and controllers.
+    /// @return The directory contract.
+    function DIRECTORY() external view returns (IJBDirectory);
+
+    /// @notice The token registry.
+    /// @return The tokens contract.
+    function TOKENS() external view returns (IJBTokens);
+
+    /// @notice The address of the deployer that created this sucker.
+    /// @return The deployer address.
+    function deployer() external view returns (address);
+
+    /// @notice The address of the peer sucker on the remote chain (as bytes32 for cross-VM compatibility).
+    /// @return The peer address.
+    function peer() external view returns (bytes32);
+
+    /// @notice The ID of the project on the local chain that this sucker is associated with.
+    /// @return The project ID.
+    function projectId() external view returns (uint256);
+
+    /// @notice The amount of tokens waiting to be added to the project's terminal balance.
+    /// @param token The terminal token address.
+    /// @return amount The outstanding amount.
+    function amountToAddToBalanceOf(address token) external view returns (uint256 amount);
+
+    /// @notice The inbox merkle tree root for a given token.
+    /// @param token The local terminal token.
+    /// @return The inbox tree root.
+    function inboxOf(address token) external view returns (JBInboxTreeRoot memory);
+
+    /// @notice Whether a token has been mapped for bridging.
+    /// @param token The local token address.
+    /// @return Whether the token is mapped.
+    function isMapped(address token) external view returns (bool);
+
+    /// @notice The outbox merkle tree for a given token.
+    /// @param token The local terminal token.
+    /// @return The outbox tree.
+    function outboxOf(address token) external view returns (JBOutboxTree memory);
+
+    /// @notice The chain ID of the remote peer.
+    /// @return chainId The remote chain ID.
+    function peerChainId() external view returns (uint256 chainId);
+
+    /// @notice Information about the remote token that a local token is mapped to.
+    /// @param token The local terminal token.
+    /// @return The remote token info.
+    function remoteTokenFor(address token) external view returns (JBRemoteToken memory);
+
+    /// @notice The current deprecation state of this sucker.
+    /// @return The sucker state.
+    function state() external view returns (JBSuckerState);
+
+    /// @notice Add the outstanding reclaimed token balance to the project's terminal.
+    /// @param token The terminal token to add to balance.
+    function addOutstandingAmountToBalance(address token) external;
+
+    /// @notice Perform multiple claims of bridged project tokens.
+    /// @param claims The claims to perform.
+    function claim(JBClaim[] calldata claims) external;
+
+    /// @notice Claim bridged project tokens for a beneficiary.
+    /// @param claimData The claim data including token, leaf, and proof.
+    function claim(JBClaim calldata claimData) external;
+
+    /// @notice Map a local token to a remote token for bridging.
+    /// @param map The token mapping to add.
+    function mapToken(JBTokenMapping calldata map) external payable;
+
+    /// @notice Map multiple local tokens to remote tokens for bridging.
+    /// @param maps The token mappings to add.
+    function mapTokens(JBTokenMapping[] calldata maps) external payable;
+
+    /// @notice Cash out project tokens and add a leaf to the outbox tree for bridging.
+    /// @param projectTokenCount The number of project tokens to cash out.
+    /// @param beneficiary The beneficiary on the remote chain (bytes32 for cross-VM compatibility).
+    /// @param minTokensReclaimed The minimum terminal tokens to receive from the cash out.
+    /// @param token The terminal token to cash out into.
+    function prepare(
+        uint256 projectTokenCount,
+        bytes32 beneficiary,
+        uint256 minTokensReclaimed,
+        address token
+    )
+        external;
+
+    /// @notice Send the outbox tree root and bridged assets to the remote peer.
+    /// @param token The terminal token to bridge.
+    function toRemote(address token) external payable;
+}

package/src/interfaces/IJBSuckerDeployer.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBTokens} from "@bananapus/core-v6/src/interfaces/IJBTokens.sol";
+
+import {IJBSucker} from "./IJBSucker.sol";
+
+/// @notice The interface for deploying sucker contracts.
+interface IJBSuckerDeployer {
+    error JBSuckerDeployer_AlreadyConfigured();
+    error JBSuckerDeployer_DeployerIsNotConfigured();
+    error JBSuckerDeployer_InvalidLayerSpecificConfiguration();
+    error JBSuckerDeployer_LayerSpecificNotConfigured();
+    error JBSuckerDeployer_Unauthorized(address caller, address expected);
+    error JBSuckerDeployer_ZeroConfiguratorAddress();
+
+    /// @notice The Juicebox directory.
+    /// @return The directory contract.
+    function DIRECTORY() external view returns (IJBDirectory);
+
+    /// @notice The token registry.
+    /// @return The tokens contract.
+    function TOKENS() external view returns (IJBTokens);
+
+    /// @notice The address authorized to set layer-specific configuration.
+    /// @return The configurator address.
+    function LAYER_SPECIFIC_CONFIGURATOR() external view returns (address);
+
+    /// @notice Whether the given address is a sucker deployed by this deployer.
+    /// @param sucker The address to check.
+    /// @return Whether the address is a deployed sucker.
+    function isSucker(address sucker) external view returns (bool);
+
+    /// @notice Deploy a new sucker for the given project.
+    /// @param localProjectId The project's ID on the local chain.
+    /// @param salt The salt for deterministic deployment.
+    /// @return sucker The newly deployed sucker.
+    function createForSender(uint256 localProjectId, bytes32 salt) external returns (IJBSucker sucker);
+}

package/src/interfaces/IJBSuckerExtended.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBSucker, JBClaim} from "./IJBSucker.sol";
+
+/// @notice Contains the IJBSucker interface and extends it with additional functions and events.
+interface IJBSuckerExtended is IJBSucker {
+    event EmergencyHatchOpened(address[] tokens, address caller);
+    event DeprecationTimeUpdated(uint40 timestamp, address caller);
+
+    /// @notice Open the emergency hatch for the specified tokens, allowing direct claims without bridging.
+    /// @param tokens The tokens to enable the emergency hatch for.
+    function enableEmergencyHatchFor(address[] calldata tokens) external;
+
+    /// @notice Claim tokens through the emergency hatch when bridging is unavailable.
+    /// @param claimData The claim data including token, leaf, and proof.
+    function exitThroughEmergencyHatch(JBClaim calldata claimData) external;
+
+    /// @notice Set or update the deprecation timestamp for this sucker.
+    /// @param timestamp The timestamp after which the sucker is deprecated.
+    function setDeprecation(uint40 timestamp) external;
+}

package/src/interfaces/IJBSuckerRegistry.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
+import {JBSuckerDeployerConfig} from "../structs/JBSuckerDeployerConfig.sol";
+import {JBSuckersPair} from "../structs/JBSuckersPair.sol";
+
+/// @notice The interface for the sucker registry, which tracks deployed suckers and manages deployer allowlists.
+interface IJBSuckerRegistry {
+    event SuckerDeployedFor(uint256 projectId, address sucker, JBSuckerDeployerConfig configuration, address caller);
+    event SuckerDeployerAllowed(address deployer, address caller);
+    event SuckerDeployerRemoved(address deployer, address caller);
+    event SuckerDeprecated(uint256 projectId, address sucker, address caller);
+
+    /// @notice The Juicebox directory.
+    /// @return The directory contract.
+    function DIRECTORY() external view returns (IJBDirectory);
+
+    /// @notice The project registry.
+    /// @return The projects contract.
+    function PROJECTS() external view returns (IJBProjects);
+
+    /// @notice Returns true if the specified sucker belongs to the specified project and was deployed through this
+    /// registry.
+    /// @param projectId The ID of the project to check for.
+    /// @param addr The address of the sucker to check.
+    /// @return Whether the sucker belongs to the project.
+    function isSuckerOf(uint256 projectId, address addr) external view returns (bool);
+
+    /// @notice Whether the specified sucker deployer is approved by this registry.
+    /// @param deployer The address of the deployer to check.
+    /// @return Whether the deployer is allowed.
+    function suckerDeployerIsAllowed(address deployer) external view returns (bool);
+
+    /// @notice Returns the pairs of suckers and their metadata for a project.
+    /// @param projectId The ID of the project.
+    /// @return pairs The local/remote sucker pairs.
+    function suckerPairsOf(uint256 projectId) external view returns (JBSuckersPair[] memory pairs);
+
+    /// @notice Returns all suckers for a project.
+    /// @param projectId The ID of the project.
+    /// @return The addresses of the suckers.
+    function suckersOf(uint256 projectId) external view returns (address[] memory);
+
+    /// @notice Add a sucker deployer to the allowlist.
+    /// @param deployer The address of the deployer to allow.
+    function allowSuckerDeployer(address deployer) external;
+
+    /// @notice Add multiple sucker deployers to the allowlist.
+    /// @param deployers The addresses of the deployers to allow.
+    function allowSuckerDeployers(address[] calldata deployers) external;
+
+    /// @notice Deploy one or more suckers for the specified project.
+    /// @param projectId The ID of the project to deploy suckers for.
+    /// @param salt The salt used for deterministic deployment.
+    /// @param configurations The deployer configs to use.
+    /// @return suckers The addresses of the deployed suckers.
+    function deploySuckersFor(
+        uint256 projectId,
+        bytes32 salt,
+        JBSuckerDeployerConfig[] calldata configurations
+    )
+        external
+        returns (address[] memory suckers);
+
+    /// @notice Remove a deprecated sucker from a project.
+    /// @param projectId The ID of the project.
+    /// @param sucker The address of the deprecated sucker to remove.
+    function removeDeprecatedSucker(uint256 projectId, address sucker) external;
+
+    /// @notice Remove a sucker deployer from the allowlist.
+    /// @param deployer The address of the deployer to remove.
+    function removeSuckerDeployer(address deployer) external;
+}

package/src/interfaces/IOPMessenger.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IOPMessenger {
+    function xDomainMessageSender() external returns (address);
+
+    function bridgeERC20To(
+        address localToken,
+        address remoteToken,
+        address to,
+        uint256 amount,
+        uint32 minGasLimit,
+        bytes calldata extraData
+    )
+        external;
+
+    function sendMessage(address target, bytes memory message, uint32 gasLimit) external payable;
+}

package/src/interfaces/IOPStandardBridge.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IOPStandardBridge {
+    /**
+     * @notice Sends ERC20 tokens to a receiver's address on the other chain. Note that if the
+     *         ERC20 token on the other chain does not recognize the local token as the correct
+     *         pair token, the ERC20 bridge will fail and the tokens will be returned to sender on
+     *         this chain.
+     *
+     * @param localToken  Address of the ERC20 on this chain.
+     * @param remoteToken Address of the corresponding token on the remote chain.
+     * @param to          Address of the receiver.
+     * @param amount      Amount of local tokens to deposit.
+     * @param minGasLimit Minimum amount of gas that the bridge can be relayed with.
+     * @param extraData   Extra data to be sent with the transaction. Note that the recipient will
+     *                     not be triggered with this data, but it will be emitted and can be used
+     *                     to identify the transaction.
+     */
+    function bridgeERC20To(
+        address localToken,
+        address remoteToken,
+        address to,
+        uint256 amount,
+        uint32 minGasLimit,
+        bytes calldata extraData
+    )
+        external;
+}

package/src/interfaces/IWrappedNativeToken.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/// @title Interface for a wrappned native token
+interface IWrappedNativeToken is IERC20 {
+    /// @notice Deposit ether to get wrapped ether
+    function deposit() external payable;
+
+    /// @notice Withdraw wrapped ether to get ether
+    function withdraw(uint256) external;
+}