Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.bungee.exchange/llms.txt

Use this file to discover all available pages before exploring further.

Building requests onchain involves creating a IBungeeInbox.Request with all required parameters, including deadline, nonce, and token specifications. The request is then submitted through the createRequest function.

​
Creating a Request

​
Step 1: Generate Request Parameters

Establish the timing and uniqueness parameters for your request: 
uint256 currentTimestamp = block.timestamp;
uint256 deadline = currentTimestamp + 600; // 10 minutes deadline
uint256 nonce = uint256(
    uint32(
        bytes4(
            keccak256(
                abi.encodePacked(
                    currentTimestamp,
                    block.number,
                    block.prevrandao,
                    msg.sender,
                    inputAmount,
                    chainSlug_,
                    gasleft()
                )
            )
        )
    )
);
The nonce generation combines multiple blockchain parameters to ensure uniqueness and prevent repeated numbers.

​
Step 2: Build the Basic Request

Create the basic request structure with chain identifiers, token details, and execution parameters: 
IBungeeInbox.BasicRequest memory basicReq = IBungeeInbox.BasicRequest({
    originChainId: request[user].inputChainSlug,
    destinationChainId: request[user].outputChainSlug,
    deadline: deadline,
    nonce: nonce,
    sender: sourceBungeeInboxAddress,
    receiver: request[user].monitorAddress,
    delegate: request[user].monitorAddress,
    bungeeGateway: sourceBungeeGatewayAddress,
    switchboardId: 1, // Fixed value for standard operations
    inputToken: request[user].inputTokenAddress,
    inputAmount: request[user].inputAmount,
    outputToken: request[user].outputTokenAddress,
    minOutputAmount: request[user].minSwapOutput,
    refuelAmount: 0 // Add refuel amount if native token transfer needed
});

​
Step 3: Complete the Request Structure

Build the full request with additional parameters for swap execution and metadata: 
IBungeeInbox.Request memory bungeeRequest = IBungeeInbox.Request({
    basicReq: basicReq,
    swapOutputToken: request[user].outputTokenAddress,
    minSwapOutput: request[user].minSwapOutput,
    metadata: bytes32(0), // Metadata: first 16 bytes = quoteId. Last 16 bytes = integrator id
    affiliateFees: "", // Add affiliate fee structure if needed
    minDestGas: 0,
    destinationPayload: "", // Add destination payload encoding if needed
    exclusiveTransmitter: address(0) // Add specific transmitter if needed
});
Detailed explanation of all parameters of both structures may be seen in the IBungeeInbox structure definition. Also, validate all inputs before creating requests to prevent invalid submissions.

​
Submitting the Request

Once your request structure is complete, submit it through the BungeeInbox contract on the source chain: 
IBungeeInbox(bungeeInboxAddress).createRequest(bungeeRequest);

​
Helper Libraries

The utility libraries below are for request handling and validation. These libraries include EIP-712 compliant hashing functions and request verification tools that ensure proper request formatting and security. 
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;

import {IBungeeInbox} from "./IBungeeInbox.sol";

/// @title Basic Request Library
/// @notice Provides helpers for handling and hashing BasicRequest structs
/// @dev Contains EIP-712 type hash and origin hash logic for BasicRequest
library BasicRequestLib {
    /// @dev EIP-712 type definition for BasicRequest struct
    bytes internal constant BASIC_REQUEST_TYPE = abi.encodePacked(
        "BasicRequest(",
        "uint256 originChainId,",
        "uint256 destinationChainId,",
        "uint256 deadline,",
        "uint256 nonce,",
        "address sender,",
        "address receiver,",
        "address delegate,",
        "address bungeeGateway,",
        "uint32 switchboardId,",
        "address inputToken,",
        "uint256 inputAmount,",
        "address outputToken,",
        "uint256 minOutputAmount,",
        "uint256 refuelAmount)"
    );
    /// @dev Keccak256 hash of the BASIC_REQUEST_TYPE
    bytes32 internal constant BASIC_REQUEST_TYPE_HASH = keccak256(BASIC_REQUEST_TYPE);

    /// @notice Computes the EIP-712 hash of a BasicRequest struct for the origin chain
    /// @dev Enforces originChainId to be the current chainId. Resulting hash is the same on all chains.
    ///      Helps avoid extra checking of chainId in the contract.
    /// @param basicReq BasicRequest object to be hashed
    /// @return bytes32 The EIP-712 hash of the BasicRequest struct
    function originHash(IBungeeInbox.BasicRequest memory basicReq) internal view returns (bytes32) {
        return keccak256(
            abi.encodePacked(
                BASIC_REQUEST_TYPE_HASH,
                abi.encode(
                    block.chainid,
                    basicReq.destinationChainId,
                    basicReq.deadline,
                    basicReq.nonce,
                    basicReq.sender,
                    basicReq.receiver,
                    basicReq.delegate,
                    basicReq.bungeeGateway,
                    basicReq.switchboardId,
                    basicReq.inputToken,
                    basicReq.inputAmount,
                    basicReq.outputToken,
                    basicReq.minOutputAmount,
                    basicReq.refuelAmount
                )
            )
        );
    }
}

/// @title Bungee Request Library.
/// @author bungee protocol
/// @notice This library is responsible for all the hashing related to Request object.
library BungeeInboxRequest {
    using BasicRequestLib for IBungeeInbox.BasicRequest;

    /// @dev EIP-712 type definition for Request struct
    bytes internal constant REQUEST_TYPE = abi.encodePacked(
        "Request(",
        "BasicRequest basicReq,",
        "address swapOutputToken,",
        "uint256 minSwapOutput,",
        "bytes32 metadata,",
        "bytes affiliateFees,",
        "uint256 minDestGas,",
        "bytes destinationPayload,",
        "address exclusiveTransmitter)"
    );

    /// @dev EIP-712 type definition for Bungee Request, including BasicRequest
    bytes internal constant BUNGEE_REQUEST_TYPE = abi.encodePacked(REQUEST_TYPE, BasicRequestLib.BASIC_REQUEST_TYPE);

    /// @dev Keccak256 hash of the BUNGEE_REQUEST_TYPE
    bytes32 internal constant BUNGEE_REQUEST_TYPE_HASH = keccak256(BUNGEE_REQUEST_TYPE);

    /**
     * @notice Creates a deterministic hash for a complete swap request
     * @dev Generates an EIP-712 compliant hash that uniquely identifies a swap request
     *      This hash is used for request tracking, validation, and preventing replay attacks
     * @param request The complete swap request structure containing all swap parameters
     * @return bytes32 The deterministic hash of the swap request
     */
    function createSORHash(IBungeeInbox.Request memory request) internal view returns (bytes32) {
        return keccak256(
            abi.encode(
                BUNGEE_REQUEST_TYPE_HASH,
                request.basicReq.originHash(),
                request.swapOutputToken,
                request.minSwapOutput,
                request.metadata,
                keccak256(request.affiliateFees),
                request.minDestGas,
                keccak256(request.destinationPayload),
                request.exclusiveTransmitter
            )
        );
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;

/// @title Bungee Inbox Interface
/// @notice Interface for submitting and handling Bungee crosschain requests
/// @dev Defines the structure and function for Bungee Inbox requests
interface IBungeeInbox {
    /// @notice Basic details in the request
    /// @dev Contains all the fundamental parameters required for a Bungee request
    struct BasicRequest {
        /// @notice Source chain ID
        uint256 originChainId;
        /// @notice Destination chain ID
        uint256 destinationChainId;
        /// @notice Deadline of the request
        uint256 deadline;
        /// @notice Nonce used for uniqueness in signature
        uint256 nonce;
        /// @notice Address of the user placing the request
        address sender;
        /// @notice Address of the receiver on destination chain
        address receiver;
        /// @notice Delegate address that has some rights over the request signed (e.g., cancellation)
        address delegate;
        /// @notice Address of bungee gateway, this address will have access to pull funds from the sender
        address bungeeGateway;
        /// @notice ID of the switchboard for settlement
        uint32 switchboardId;
        /// @notice Address of the input token
        address inputToken;
        /// @notice Amount of the input token
        uint256 inputAmount;
        /// @notice Output token to be received on the destination
        address outputToken;
        /// @notice Minimum amount of output token to be received on the destination
        uint256 minOutputAmount;
        /// @notice Native token refuel amount on the destination chain
        uint256 refuelAmount;
    }

    /// @notice The Request which user signs
    /// @dev Contains all parameters for a complete Bungee request, including swap and execution details
    struct Request {
        /// @notice Basic details in the request
        BasicRequest basicReq;
        /// @notice Swap output token that the user is permitting to swap input token to
        address swapOutputToken;
        /// @notice Minimum swap output the user is okay with swapping the input token to
        /// @dev Transmitter can choose or not choose to swap tokens
        uint256 minSwapOutput;
        /// @notice Any sort of metadata to be passed with the request
        bytes32 metadata;
        /// @notice Fees of the affiliate if any
        bytes affiliateFees;
        /// @notice Minimum destination gas limit to execute calldata on destination
        /// @dev Only to be used when execution is required on destination
        uint256 minDestGas;
        /// @notice Calldata to be executed on the destination
        /// @dev Calldata can only be executed on the receiver in the request
        bytes destinationPayload;
        /// @notice Address of the only transmitter that is permitted to execute the request
        /// @dev If the transmitter is not set, anyone can execute the request. This validation would be done off-chain by the auction house
        address exclusiveTransmitter;
    }

    /// @notice Creates a new Bungee request
    /// @dev Accepts a complete Request struct and processes it. May require a payment depending on the request.
    /// @param singleOutputRequest The complete request structure containing all parameters
    function createRequest(Request calldata singleOutputRequest) external payable;
}