> For the complete documentation index, see [llms.txt](https://defivaults.gitbook.io/amphor/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://defivaults.gitbook.io/amphor/technical/v1/vaultzapper.md).

# VaultZapper

## VaultZapper

[Git Source](https://github.com/AmphorProtocol/asynchronous-synthetic-private/blob/c4f7a9b8f3d3d9aba0e43eaae38ef9b556023b0e/src/VaultZapper.sol)

**Inherits:** Ownable2Step, Pausable

### State Variables

#### authorizedVaults

The `authorizedVaults` mapping is used to check if a vault is authorized to interact with the `VaultZapper` contract.

*The `SafeERC20` lib is only used for `safeTransfer`, `safeTransferFrom` and `forceApprove` operations.*

*The `Address` lib is only used for `sendValue` operations.*

```solidity
mapping(IERC4626 vault => bool isAuthorized) public authorizedVaults;
```

#### authorizedRouters

The `authorizedRouters` mapping is used to check if a router is authorized to interact with the `VaultZapper` contract.

```solidity
mapping(address routerAddress => bool isAuthorized) public authorizedRouters;
```

### Functions

#### onlyAllowedRouter

*The `onlyAllowedRouter` modifier is used to check if a router is authorized to interact with the `VaultZapper` contract.*

```solidity
modifier onlyAllowedRouter(address router);
```

#### onlyAllowedVault

*The `onlyAllowedVault` modifier is used to check if a vault is authorized to interact with the `VaultZapper` contract.*

```solidity
modifier onlyAllowedVault(IERC4626 vault);
```

#### constructor

```solidity
constructor() Ownable(_msgSender());
```

#### withdrawToken

*The `withdrawToken` function is used to withdraw tokens from the `VaultZapper` contract.*

```solidity
function withdrawToken(IERC20 token) external onlyOwner;
```

#### withdrawNativeToken

*The `withdrawNativeToken` function is used to withdraw native tokens from the `VaultZapper` contract.*

```solidity
function withdrawNativeToken() external onlyOwner;
```

#### pause

*The `pause` function is used to pause the `VaultZapper` contract.*

```solidity
function pause() external onlyOwner;
```

#### unpause

*The `unpause` function is used to unpause the `VaultZapper` contract.*

```solidity
function unpause() external onlyOwner;
```

#### approveTokenForRouter

*The `approveTokenForRouter` function is used to approve a token for a router.*

```solidity
function approveTokenForRouter(
    IERC20 token,
    address router
)
    public
    onlyOwner
    onlyAllowedRouter(router);
```

#### toggleRouterAuthorization

*The `toggleRouterAuthorization` function is used to toggle the authorization of a router.*

```solidity
function toggleRouterAuthorization(address router) public onlyOwner;
```

#### toggleVaultAuthorization

*The `toggleVaultAuthorization` function is used to toggle the authorization of a vault.*

```solidity
function toggleVaultAuthorization(IERC7540 vault) public onlyOwner;
```

#### \_zapIn

*The `_zapIn` function is used to zap in assets into a vault.*

```solidity
function _zapIn(
    IERC20 tokenIn,
    address router,
    uint256 amount,
    bytes calldata data
)
    internal;
```

#### \_transferTokenInAndApprove

*The `_transferTokenInAndApprove` function is used to transfer tokens into the `VaultZapper` contract and approve them for a router.*

```solidity
function _transferTokenInAndApprove(
    address router,
    IERC20 tokenIn,
    uint256 amount
)
    internal;
```

#### zapAndDeposit

*The `zapAndDeposit` function is used to zap in and deposit assets into a vault.*

```solidity
function zapAndDeposit(
    IERC20 tokenIn,
    IERC4626 vault,
    address router,
    uint256 amount,
    bytes calldata data
)
    public
    payable
    onlyAllowedRouter(router)
    onlyAllowedVault(vault)
    whenNotPaused
    returns (uint256);
```

#### zapAndRequestDeposit

*The `zapAndRequestDeposit` function is used to zap in and request a deposit of assets into a vault.*

```solidity
function zapAndRequestDeposit(
    IERC20 tokenIn,
    IERC7540 vault,
    address router,
    uint256 amountIn,
    bytes calldata data,
    bytes calldata swapData
)
    public
    payable
    onlyAllowedRouter(router)
    onlyAllowedVault(vault)
    whenNotPaused;
```

#### zapAndClaimAndRequestDeposit

*The `zapAndClaimAndRequestDeposit` function is used to zap in, claim and request a deposit of assets into a vault.*

```solidity
function zapAndClaimAndRequestDeposit(
    IERC20 tokenIn,
    AsyncSynthVault vault,
    address router,
    uint256 amountIn,
    bytes calldata data,
    bytes calldata swapData
)
    public
    payable
    onlyAllowedRouter(router)
    onlyAllowedVault(vault)
    whenNotPaused;
```

#### zapAndDepositWithPermit

*The `zapAndDepositWithPermit` function is used to zap in and deposit assets into a vault with a permit.*

```solidity
function zapAndDepositWithPermit(
    IERC20 tokenIn,
    IERC4626 vault,
    address router,
    uint256 amount,
    bytes calldata swapData,
    PermitParams calldata permitParams
)
    public
    returns (uint256);
```

#### zapAndRequestDepositWithPermit

*The `zapAndRequestDepositWithPermit` function is used to zap in and request a deposit of assets into a vault with a permit.*

```solidity
function zapAndRequestDepositWithPermit(
    IERC20 tokenIn,
    IERC7540 vault,
    address router,
    uint256 amount,
    bytes calldata data,
    bytes calldata swapData,
    PermitParams calldata permitParams
)
    public;
```

#### zapAndClaimAndRequestDepositWithPermit

*The `zapAndClaimAndRequestDepositWithPermit` function is used to zap in, claim and request a deposit of assets into a vault with a permit.*

```solidity
function zapAndClaimAndRequestDepositWithPermit(
    IERC20 tokenIn,
    AsyncSynthVault vault,
    address router,
    uint256 amount,
    bytes calldata data,
    bytes calldata swapData,
    PermitParams calldata permitParams
)
    public;
```

#### \_executeZap

*The `_executeZap` function is used to execute a zap.*

```solidity
function _executeZap(
    address target,
    bytes memory data
)
    internal
    returns (bytes memory response);
```

#### \_executePermit

*The `_executePermit` function is used to execute a permit.*

```solidity
function _executePermit(
    IERC20 token,
    address owner,
    address spender,
    PermitParams calldata permitParams
)
    internal;
```

### Events

#### ZapAndRequestDeposit

*The `ZapAndDeposit` event is emitted when a user zaps in and deposits assets into a vault.*

```solidity
event ZapAndRequestDeposit(
    IERC7540 indexed vault,
    address indexed router,
    IERC20 tokenIn,
    uint256 amount
);
```

#### ZapAndDeposit

*The `ZapAndDeposit` event is emitted when a user zaps in and deposits assets into a vault.*

```solidity
event ZapAndDeposit(
    IERC4626 indexed vault,
    address indexed router,
    IERC20 tokenIn,
    uint256 amount,
    uint256 shares
);
```

#### ClaimRedeemAndZap

*The `ClaimRedeemAndZap` event is emitted when a user claims, redeems and zaps assets into a vault.*

```solidity
event ClaimRedeemAndZap(
    IERC7540 indexed vault,
    address indexed router,
    uint256 shares,
    uint256 assets
);
```

#### RouterApproved

*The `RouterApproved` event is emitted when a router is approved to interact with a token.*

```solidity
event RouterApproved(address indexed router, IERC20 indexed token);
```

#### RouterAuthorized

*The `RouterAuthorized` event is emitted when a router is authorized to interact with the `VaultZapper` contract.*

```solidity
event RouterAuthorized(address indexed router, bool allowed);
```

#### VaultAuthorized

*The `VaultAuthorized` event is emitted when a vault is authorized to interact with the `VaultZapper` contract.*

```solidity
event VaultAuthorized(IERC4626 indexed vault, bool allowed);
```

### Errors

#### NotRouter

*The `NotRouter` error is emitted when a router is not authorized to interact with the `VaultZapper` contract.*

```solidity
error NotRouter(address router);
```

#### NotVault

*The `NotVault` error is emitted when a vault is not authorized to interact with the `VaultZapper` contract.*

```solidity
error NotVault(IERC4626 vault);
```

#### SwapFailed

*The `SwapFailed` error is emitted when a swap fails.*

```solidity
error SwapFailed(string reason);
```

#### InconsistantSwapData

*The `InconsistantSwapData` error is emitted when the swap data is inconsistant.*

```solidity
error InconsistantSwapData(
    uint256 expectedTokenInBalance, uint256 actualTokenInBalance
);
```

#### NotEnoughSharesMinted

*The `NotEnoughSharesMinted` error is emitted when the amount of shares minted is not enough.*

```solidity
error NotEnoughSharesMinted(uint256 sharesMinted, uint256 minSharesMinted);
```

#### NotEnoughUnderlying

*The `NotEnoughUnderlying` error is emitted when the amount of underlying assets is not enough.*

```solidity
error NotEnoughUnderlying(
    uint256 previewedUnderlying, uint256 withdrawedUnderlying
);
```

#### NullMinShares

*The `NullMinShares` error is emitted when the minimum amount of shares to mint is null.*

```solidity
error NullMinShares();
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://defivaults.gitbook.io/amphor/technical/v1/vaultzapper.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.