> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kuru.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Router Contract Documentation

> The Router contract is the central orchestrator of the Kuru trading system. It manages market deployment and enables complex multi-hop swaps across different markets.

## State Variables

### Public Variables

| Variable                     | Type    | Description                                 |
| ---------------------------- | ------- | ------------------------------------------- |
| `orderBookImplementation`    | address | Current OrderBook implementation address    |
| `kuruAmmVaultImplementation` | address | Current KuruAMMVault implementation address |
| `marginAccountAddress`       | address | MarginAccount contract address              |
| `TRUSTED_FORWARDER`          | address | Address for meta-transaction forwarding     |

### Mappings

```solidity theme={null}
mapping(address => MarketParams) public verifiedMarket;
```

Stores market parameters for each deployed OrderBook. Used to validate markets during swaps.

## Core Functions

### initialize

One-time initialization of the Router contract.

```solidity theme={null}
function initialize(
    address _owner,
    address _marginAccount,
    address _orderbookImplementation,
    address _kuruAmmVaultImplementation,
    address _trustedForwarder
) public initializer
```

Sets the contract owner and core component addresses. Can only be called once. Required before deploying any markets.

### deployProxy

Deploys a new OrderBook market with an associated KuruAMMVault.

```solidity theme={null}
function deployProxy(
    IOrderBook.OrderBookType _type,
    address _baseAssetAddress,
    address _quoteAssetAddress,
    uint96 _sizePrecision,
    uint32 _pricePrecision,
    uint32 _tickSize,
    uint96 _minSize,
    uint96 _maxSize,
    uint256 _takerFeeBps,
    uint256 _makerFeeBps,
    uint96 _kuruAmmSpread
) public returns (address proxy)
```

**Market Types:**

* `NO_NATIVE` - Both base and quote are ERC20 tokens
* `NATIVE_IN_BASE` - Native token (Monad) as base asset
* `NATIVE_IN_QUOTE` - Native token (Monad) as quote asset

Deploys both OrderBook and KuruAMMVault using Create2 for deterministic addresses. Registers the market in `verifiedMarket` mapping. Returns the deployed OrderBook proxy address.

### computeAddress

Computes the deterministic address for an OrderBook proxy.

```solidity theme={null}
function computeAddress(
    address _baseAssetAddress,
    address _quoteAssetAddress,
    uint96 _sizePrecision,
    uint32 _pricePrecision,
    uint32 _tickSize,
    uint96 _minSize,
    uint96 _maxSize,
    uint256 _takerFeeBps,
    uint256 _makerFeeBps,
    uint96 _kuruAmmSpread,
    address oldImplementation,
    bool old
) public view returns (address proxy)
```

Pre-computes the deployment address before actual deployment. Supports implementation upgrades while preserving addresses.

### computeVaultAddress

Computes the deterministic address for a KuruAMMVault.

```solidity theme={null}
function computeVaultAddress(
    address _marketAddress,
    address oldImplementation,
    bool old
) public view returns (address)
```

Pre-computes the vault address for a given market address. Used for planning and verification.

### anyToAnySwap

Enables multi-hop swaps across different markets.

```solidity theme={null}
function anyToAnySwap(
    address[] calldata _marketAddresses,
    bool[] calldata _isBuy,
    bool[] calldata _nativeSend,
    address _debitToken,
    address _creditToken,
    uint256 _amount,
    uint256 _minAmountOut
) external payable returns (uint256 _amountOut)
```

Routes swaps through multiple markets. Validates each market via `verifiedMarket` mapping and enforces slippage protection via `_minAmountOut`. Supports native token transfers when `_nativeSend` is true.

**Example:** Swap TOKEN\_A → Native → TOKEN\_B

```javascript theme={null}
const markets = [tokenAMarket, nativeMarket];
const isBuy = [false, false];  // Sell TOKEN_A, sell Native
const nativeSend = [false, true];

await router.anyToAnySwap(
    markets, isBuy, nativeSend,
    tokenA, tokenB, amount, minAmountOut,
    { value: nativeAmount }
);
```

***

## Events

### MarketRegistered

```solidity theme={null}
event MarketRegistered(
    address baseAsset,
    address quoteAsset,
    address market,
    address vaultAddress,
    uint32 pricePrecision,
    uint96 sizePrecision,
    uint32 tickSize,
    uint96 minSize,
    uint96 maxSize,
    uint256 takerFeeBps,
    uint256 makerFeeBps,
    uint96 kuruAmmSpread
);
```

Emitted when a new market is successfully deployed via `deployProxy`. Contains all market parameters and addresses for the OrderBook and KuruAMMVault.

### OBImplementationUpdated

```solidity theme={null}
event OBImplementationUpdated(
    address previousImplementation,
    address newImplementation
);
```

Emitted when the OrderBook implementation address is updated. Future market deployments will use the new implementation.

### VaultImplementationUpdated

```solidity theme={null}
event VaultImplementationUpdated(
    address previousImplementation,
    address newImplementation
);
```

Emitted when the KuruAMMVault implementation address is updated. Future vault deployments will use the new implementation.

### KuruRouterSwap

```solidity theme={null}
event KuruRouterSwap(
    address msgSender,
    address debitToken,
    address creditToken,
    uint256 amountIn,
    uint256 amountOut
);
```

Emitted after a successful multi-hop swap via `anyToAnySwap`. Tracks the swap input/output for the entire routing path.