Protocol Roles

/**
 * @notice Standard deposit with explicit parameters.
 */
function deposit(
    bytes32 depositor,
    bytes32 recipient,
    bytes32 inputToken,
    bytes32 outputToken,
    uint256 inputAmount,
    uint256 outputAmount,
    uint256 destinationChainId,
    bytes32 exclusiveRelayer,
    uint32 quoteTimestamp,
    uint32 fillDeadline,
    uint32 exclusivityParameter,
    bytes calldata message
) public payable;

/**
 * @notice Fill a deposit by sending outputAmount to recipient.
 * Relayer fronts capital and will be refunded via merkle proof.
 */
function fillRelay(
    bytes32 depositor,
    bytes32 recipient,
    bytes32 inputToken,
    bytes32 outputToken,
    uint256 inputAmount,
    uint256 outputAmount,
    uint256 originChainId,
    uint32 depositId,
    uint32 fillDeadline,
    uint32 exclusivityDeadline,
    bytes calldata message
) external nonReentrant unpausedFills;

/**
 * @notice Publish a new root bundle. Caller stakes a bond.
 */
function proposeRootBundle(
    uint256[] calldata bundleEvaluationBlockNumbers,
    uint8 poolRebalanceLeafCount,
    bytes32 poolRebalanceRoot,
    bytes32 relayerRefundRoot,
    bytes32 slowRelayRoot
) public override nonReentrant noActiveRequests unpaused {
    require(poolRebalanceLeafCount > 0, "Bundle must have at least 1 leaf");

    uint32 challengePeriodEndTimestamp = uint32(getCurrentTime()) + liveness;

    delete rootBundleProposal;

    rootBundleProposal.challengePeriodEndTimestamp = challengePeriodEndTimestamp;
    rootBundleProposal.unclaimedPoolRebalanceLeafCount = poolRebalanceLeafCount;
    rootBundleProposal.poolRebalanceRoot = poolRebalanceRoot;
    rootBundleProposal.relayerRefundRoot = relayerRefundRoot;
    rootBundleProposal.slowRelayRoot = slowRelayRoot;
    rootBundleProposal.proposer = msg.sender;

    bondToken.safeTransferFrom(msg.sender, address(this), bondAmount);

    emit ProposeRootBundle(
        challengePeriodEndTimestamp,
        poolRebalanceLeafCount,
        bundleEvaluationBlockNumbers,
        poolRebalanceRoot,
        relayerRefundRoot,
        slowRelayRoot,
        msg.sender
    );
}

/**
 * @notice Stake a bond to dispute the current root bundle.
 * Proposal is deleted and dispute sent to optimistic oracle.
 */
function disputeRootBundle() public nonReentrant zeroOptimisticOracleApproval {
    uint32 currentTime = uint32(getCurrentTime());
    require(currentTime <= rootBundleProposal.challengePeriodEndTimestamp, 
            "Request passed liveness");

    uint256 finalFee = _getBondTokenFinalFee();

    if (finalFee >= bondAmount) {
        _cancelBundle();
        return;
    }

    SkinnyOptimisticOracleInterface optimisticOracle = _getOptimisticOracle();

    bondToken.safeIncreaseAllowance(address(optimisticOracle), bondAmount);
    
    try optimisticOracle.requestAndProposePriceFor(
        identifier,
        currentTime,
        "",
        bondToken,
        0,
        bondAmount - finalFee,
        liveness,
        rootBundleProposal.proposer,
        int256(1e18)
    ) returns (uint256) {
        bondToken.safeApprove(address(optimisticOracle), 0);
    } catch {
        _cancelBundle();
        return;
    }

    // Construct price request and dispute it
    SkinnyOptimisticOracleInterface.Request memory ooPriceRequest = 
        SkinnyOptimisticOracleInterface.Request({
            proposer: rootBundleProposal.proposer,
            disputer: address(0),
            currency: bondToken,
            settled: false,
            proposedPrice: int256(1e18),
            resolvedPrice: 0,
            expirationTime: currentTime + liveness,
            reward: 0,
            finalFee: finalFee,
            bond: bondAmount - finalFee,
            customLiveness: liveness
        });

    delete rootBundleProposal;

    bondToken.safeTransferFrom(msg.sender, address(this), bondAmount);
    bondToken.safeIncreaseAllowance(address(optimisticOracle), bondAmount);
    optimisticOracle.disputePriceFor(
        identifier, 
        currentTime, 
        "", 
        ooPriceRequest, 
        msg.sender, 
        address(this)
    );

    emit RootBundleDisputed(msg.sender, currentTime);
}

/**
 * @notice Deposit liquidity to earn LP fees.
 * Caller receives LP tokens representing their pool share.
 */
function addLiquidity(
    address l1Token, 
    uint256 l1TokenAmount
) public payable override nonReentrant unpaused {
    require(pooledTokens[l1Token].isEnabled, "Token not enabled");
    require(((address(weth) == l1Token) && msg.value == l1TokenAmount) || msg.value == 0, 
            "Bad msg.value");

    uint256 lpTokensToMint = (l1TokenAmount * 1e18) / _exchangeRateCurrent(l1Token);
    pooledTokens[l1Token].liquidReserves += l1TokenAmount;
    ExpandedIERC20(pooledTokens[l1Token].lpToken).mint(msg.sender, lpTokensToMint);

    if (address(weth) == l1Token && msg.value > 0) 
        WETH9Interface(address(l1Token)).deposit{ value: msg.value }();
    else 
        IERC20(l1Token).safeTransferFrom(msg.sender, address(this), l1TokenAmount);

    emit LiquidityAdded(l1Token, l1TokenAmount, lpTokensToMint, msg.sender);
}