Wrapper contract - nexroute

The wrapper contract is a thin Solidity contract deployed by nexroute on each supported chain. It accepts a single calldata blob containing the user’s Permit2 authorisation, the aggregator swap calldata, and nexroute’s backrun calldata, and executes them atomically in one transaction. Use this shape when you want the simplest integration: no partner contract changes, no router modifications, just a single function call from the user’s transaction.

Interface

function execute(
    ISignatureTransfer.PermitTransferFrom calldata permit,
    bytes calldata signature,
    bytes calldata swapData,
    bytes calldata backrunData
) external;

execute is the entrypoint partners call. It handles the Permit2 pull, the aggregator swap, and the backrun atomically.

Flow

Get aggregator swap calldata. Set receiver = user so output tokens go directly to the end user, not the wrapper.
Ask nexroute for a backrun via the backrun API.
Have the user sign a Permit2 PermitTransferFrom typed-data message with spender = <wrapper address>, permitted.token = <input token>, permitted.amount = <amount in>.
ABI-encode execute(permit, signature, swapData, backrunData) and submit it as the user’s transaction.

What you receive from nexroute

A JSON-RPC envelope from the eth_backrun API. The fields used by this shape:

Field	Description
`calldata`	pass as the `backrunData` argument to `execute(...)`
`contract`	not used in this shape; the wrapper handles backrun dispatch internally

When the JSON-RPC result is null, no arbitrage opportunity was found. Either skip the wrapper entirely and submit the user’s swap directly, or call execute(...) with backrunData = "0x" so the wrapper’s internal backrun step is a no-op.

Permit2 signature

The user signs the Permit2 typed-data domain. Domain values:

const domain = {
    name: "Permit2",
    chainId,
    verifyingContract: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
};
const types = {
    PermitTransferFrom: [
        { name: "permitted", type: "TokenPermissions" },
        { name: "spender", type: "address" },
        { name: "nonce", type: "uint256" },
        { name: "deadline", type: "uint256" },
    ],
    TokenPermissions: [
        { name: "token", type: "address" },
        { name: "amount", type: "uint256" },
    ],
};
const value = {
    permitted: { token: inputToken, amount: amountIn },
    spender: wrapperAddress,
    nonce,
    deadline,
};
const signature = await user.signTypedData(domain, types, value);

The user must have approved Permit2 (0x000000000022D473030F116dDEE9F6B43aC78BA3) for the input token at least once. After that, every Embedded transaction is one off-chain signature.

Building the execute call

const wrapper = new ethers.Contract(wrapperAddress, wrapperAbi, provider);

const tx = await wrapper.connect(user).execute.populateTransaction(
    {
        permitted: { token: inputToken, amount: amountIn },
        nonce,
        deadline,
    },
    signature,
    swapData,    // aggregator calldata
    backrunData, // from nexroute backrun API
);

// submit `tx` through any RPC, or through a private relay for mempool privacy

Submission

The resulting transaction can be submitted through any RPC. For mempool privacy, submit through a private relay.

Invariants

Permit2 spender must equal the wrapper contract address.
The aggregator swap calldata must set receiver = user. Otherwise output tokens stay in the wrapper and are swept to the nexroute fee wallet.
The wrapper holds an allowance to the target aggregator only for the duration of the swap; allowance is revoked before the backrun runs.

Failure modes

Permit2 signature invalid or expired: revert before any funds move.
Aggregator swap reverts: revert; Permit2 pull is rolled back atomically. User loses only gas.
Backrun reverts: caught silently. User swap still completes. User pays gas for the failed attempt.

Gas

Approximate execute gas cost: 200k–350k depending on the depth of the backrun arbitrage path. The wrapper itself adds roughly 60k–80k over a direct aggregator call (Permit2 pull, approval, revoke, delegatecall).

Deployments

Contract addresses per chain are published as part of integrator onboarding. Contact nexroute for current addresses on your target chain(s).

​Interface

​Flow

​What you receive from nexroute

​Permit2 signature

​Building the execute call

​Submission

​Invariants

​Failure modes

​Gas

​Deployments