Provider contract - Biconomy Docs

Your inventory lives in a contract you own that implements IMMProvider. The executor calls it to settle each fill.

interface IMMProvider {
    function signer() external view returns (address);
    function previewSwap(address tokenIn, address tokenOut, uint256 amountIn, uint256 anchorPrice)
        external view returns (uint256 amountOut);
    function available(address token) external view returns (uint256);
    function executeSwap(address tokenIn, address tokenOut, uint256 amountIn, uint256 anchorPrice, uint256 amountOut, address receiver)
        external returns (uint256 delivered);
}

Function	Called by	Must
`signer()`	executor, on every fill and in `board()` and `quote()`	return the address that signs your ladders (EOA, or EIP-1271 contract checked with a 150,000 gas budget); while it differs from the ladder’s `mm`, the board reports dark
`previewSwap(...)`	Biconomy, offchain, before routing to you	return what `executeSwap` would deliver for the same inputs, or `0` to decline
`available(token)`	executor, in `board()`, `quote()` and every venue quote	return how much of `token` the provider can pay out right now
`executeSwap(...)`	executor only	pull `amountIn` of `tokenIn` from the executor, send `amountOut` of `tokenOut` to `receiver`, return the amount sent

executeSwap parameters

Parameter	Value
`tokenIn`	token the taker pays
`tokenOut`	token you deliver
`amountIn`	amount the executor has approved you to pull with `transferFrom`
`anchorPrice`	average price of this fill, `amountOut * 1e18 / amountIn`. Optional input for contracts that price from their own state
`amountOut`	amount your signed ladder pays for `amountIn`, computed by the executor from your stored ladder
`receiver`	address that receives `tokenOut`
returns `delivered`	amount of `tokenOut` sent to `receiver`

The executor computes amountOut only from a ladder your key signed, within its size, expiry and protections. Delivering less than amountOut makes the trade revert on the taker’s minAmountOut.

available

The executor caps each board to what available(tokenOut) returns: board() reports the smaller remaining size and quote() returns 0 for a size the provider cannot pay. The venue therefore quotes only what makers can pay.

Rule	Detail
Gas	read with a 50,000 gas budget; keep it a cheap view
Return	only the first 32 bytes are used
Failure	a revert, out-of-gas or short return counts as unbounded
Scope	a wrong answer only affects your own board

Deploy BasicMMProvider

BasicMMProvider.sol is the reference implementation. It accepts fills from the executor only, pays amountOut, and returns its own token balance from available. It does not accept native ETH.

Constructor argument	Value
`signer`	address that signs your ladders
`executor`	the executor address, see Addresses
`owner`	admin address; use a multisig in production

Dependency	Path
`IMMProvider.sol`	`src/interfaces/IMMProvider.sol`
`BasicMMProvider.sol`	`src/periphery/examples/BasicMMProvider.sol`
solady	`forge install vectorized/solady`

Owner function	Effect
`setSigner(address)`	Changes the signing key. Ladders signed by the old key stop filling and stop quoting at once.
`setApprovedExecutor(address)`	Changes which contract may call `executeSwap`. Any other address stops all fills.
`withdraw(token, amount, to)`	Moves inventory out.

Implement IMMProvider on an existing contract

If your inventory already sits in a contract, add the four functions to it.

Requirement	Detail
Caller check	`executeSwap` reverts unless `msg.sender` is the executor
Pull input	`transferFrom(executor, address(this), amountIn)` on `tokenIn`
Pay output	transfer `amountOut` of `tokenOut` to `receiver` and return it
Inventory	`available(token)` returns what the contract can pay out now, for example its balance, or for a vault the smaller of its balance and the allowance it granted
Preview	`previewSwap` matches `executeSwap` for the same inputs, or returns `0`
Optional ceiling	revert when `amountOut` exceeds a per-fill limit you set