Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: SAL-1.0

/**
 * WAGMI  Leverage Protocol Vault v2.0
 * wagmi.com
 */

pragma solidity 0.8.23;

import "@openzeppelin/contracts/access/Ownable.sol";
import "./interfaces/IVault.sol";
import "./interfaces/IWagmiLeverageFlashCallback.sol";
import "./vendor0.8/uniswap/FullMath.sol";
import { TransferHelper } from "./libraries/TransferHelper.sol";

contract Vault is Ownable, IVault {
    using TransferHelper for address;

    uint24 internal constant MAX_FLASH_FEE = 10000; // 1.00%

    uint24 private immutable defaultFlashFee;

    mapping(address => uint24) public flashFeeForToken;

    constructor(uint24 _defaultFlashFee) {
        defaultFlashFee = _defaultFlashFee;
    }

    function setFlashFee(address token, uint24 flashFee) external onlyOwner {
        require(flashFee <= MAX_FLASH_FEE, "V-FE");
        flashFeeForToken[token] = flashFee;
    }

    function vaultFlash(address token, uint256 amount, bytes calldata data) external onlyOwner {
        uint256 balanceBefore = token.getBalance();

        if (balanceBefore < amount) amount = balanceBefore;
        uint256 feeAmt;
        if (amount > 0) {
            uint24 flashFee = flashFeeForToken[token];
            if (flashFee == 0) {
                flashFee = defaultFlashFee;
            }
            feeAmt = FullMath.mulDivRoundingUp(amount, flashFee, 1e6);
            token.safeTransfer(msg.sender, amount);
            balanceBefore += feeAmt;
        }

        IWagmiLeverageFlashCallback(msg.sender).wagmiLeverageFlashCallback(amount, feeAmt, data);
        uint256 balanceAfter = token.getBalance();
        require(balanceBefore <= balanceAfter, "V-FL");

        if (amount > 0) emit VaultFlash(token, amount, feeAmt);
    }

    /**
     * @notice Transfers tokens to a specified address
     * @param _token The address of the token to be transferred
     * @param _to The address to which the tokens will be transferred
     * @param _amount The amount of tokens to be transferred
     */
    function transferToken(address _token, address _to, uint256 _amount) external onlyOwner {
        if (_amount > 0) {
            _token.safeTransfer(_to, _amount);
        }
    }

    /**
     * @dev Retrieves the balances of multiple tokens for this contract.
     * @param tokens The array of token addresses for which to retrieve the balances.
     * @return balances An array of uint256 values representing the balances of the corresponding tokens in the `tokens` array.
     */
    function getBalances(
        address[] calldata tokens
    ) external view returns (uint256[] memory balances) {
        uint256 length = tokens.length;
        balances = new uint256[](length);
        for (uint256 i; i < length; ) {
            balances[i] = tokens[i].getBalance();
            unchecked {
                ++i;
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;

// Interface for the Vault contract
interface IVault {
    event VaultFlash(address token, uint256 amount, uint256 fee);

    // Function to transfer tokens from the vault to a specified address
    function transferToken(address _token, address _to, uint256 _amount) external;

    function vaultFlash(address token, uint256 amount, bytes calldata data) external;

    function setFlashFee(address token, uint24 flashFee) external;

    // Function to get the balances of multiple tokens
    function getBalances(
        address[] calldata tokens
    ) external view returns (uint256[] memory balances);

    function flashFeeForToken(address token) external view returns (uint24);
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.0;

interface IWagmiLeverageFlashCallback {
    function wagmiLeverageFlashCallback(
        uint256 bodyAmt,
        uint256 feeAmt,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: GPL-2.0-or-later
// https://github.com/Uniswap/v3-periphery/blob/main/contracts/libraries/TransferHelper.sol
pragma solidity 0.8.23;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(address token, address from, address to, uint256 value) internal {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value)
        );
        require(success && (data.length == 0 || abi.decode(data, (bool))), "W-STF");
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(address token, address to, uint256 value) internal {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(IERC20.transfer.selector, to, value)
        );
        require(success && (data.length == 0 || abi.decode(data, (bool))), "W-ST");
    }

    function getBalance(address token) internal view returns (uint256 balance) {
        bytes memory callData = abi.encodeWithSelector(IERC20.balanceOf.selector, address(this));
        (bool success, bytes memory data) = token.staticcall(callData);
        require(success && data.length >= 32);
        balance = abi.decode(data, (uint256));
    }

    function getBalanceOf(address token, address target) internal view returns (uint256 balance) {
        bytes memory callData = abi.encodeWithSelector(IERC20.balanceOf.selector, target);
        (bool success, bytes memory data) = token.staticcall(callData);
        require(success && data.length >= 32);
        balance = abi.decode(data, (uint256));
    }
}

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

/// @title Contains 512-bit math functions
/// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision
/// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits
library FullMath {
    /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
    /// @param a The multiplicand
    /// @param b The multiplier
    /// @param denominator The divisor
    /// @return result The 256-bit result
    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv
    function mulDiv(
        uint256 a,
        uint256 b,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = a * b
            // Compute the product mod 2**256 and mod 2**256 - 1
            // then use the Chinese Remainder Theorem to reconstruct
            // the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2**256 + prod0
            uint256 prod0 = a * b; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(a, b, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Make sure the result is less than 2**256.
            // Also prevents denominator == 0
            require(denominator > prod1);

            // Handle non-overflow cases, 256 by 256 division
            if (prod1 == 0) {
                assembly {
                    result := div(prod0, denominator)
                }
                return result;
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0]
            // Compute remainder using mulmod
            uint256 remainder;
            assembly {
                remainder := mulmod(a, b, denominator)
            }
            // Subtract 256 bit number from 512 bit number
            assembly {
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator
            // Compute largest power of two divisor of denominator.
            // Always >= 1.
            uint256 twos = (0 - denominator) & denominator;
            // Divide denominator by power of two
            assembly {
                denominator := div(denominator, twos)
            }

            // Divide [prod1 prod0] by the factors of two
            assembly {
                prod0 := div(prod0, twos)
            }
            // Shift in bits from prod1 into prod0. For this we need
            // to flip `twos` such that it is 2**256 / twos.
            // If twos is zero, then it becomes one
            assembly {
                twos := add(div(sub(0, twos), twos), 1)
            }
            prod0 |= prod1 * twos;

            // Invert denominator mod 2**256
            // Now that denominator is an odd number, it has an inverse
            // modulo 2**256 such that denominator * inv = 1 mod 2**256.
            // Compute the inverse by starting with a seed that is correct
            // correct for four bits. That is, denominator * inv = 1 mod 2**4
            uint256 inv = (3 * denominator) ^ 2;
            // Now use Newton-Raphson iteration to improve the precision.
            // Thanks to Hensel's lifting lemma, this also works in modular
            // arithmetic, doubling the correct bits in each step.
            inv *= 2 - denominator * inv; // inverse mod 2**8
            inv *= 2 - denominator * inv; // inverse mod 2**16
            inv *= 2 - denominator * inv; // inverse mod 2**32
            inv *= 2 - denominator * inv; // inverse mod 2**64
            inv *= 2 - denominator * inv; // inverse mod 2**128
            inv *= 2 - denominator * inv; // inverse mod 2**256

            // Because the division is now exact we can divide by multiplying
            // with the modular inverse of denominator. This will give us the
            // correct result modulo 2**256. Since the preconditions guarantee
            // that the outcome is less than 2**256, this is the final result.
            // We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inv;
            return result;
        }
    }

    /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
    /// @param a The multiplicand
    /// @param b The multiplier
    /// @param denominator The divisor
    /// @return result The 256-bit result
    function mulDivRoundingUp(
        uint256 a,
        uint256 b,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            result = mulDiv(a, b, denominator);
            if (mulmod(a, b, denominator) > 0) {
                require(result < type(uint256).max);
                result++;
            }
        }
    }
}

{
  "viaIR": true,
  "evmVersion": "paris",
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint24","name":"_defaultFlashFee","type":"uint24"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"VaultFlash","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"flashFeeForToken","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"name":"getBalances","outputs":[{"internalType":"uint256[]","name":"balances","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint24","name":"flashFee","type":"uint24"}],"name":"setFlashFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"vaultFlash","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x60406080815260048036101561001457600080fd5b600091823560e01c9182632d2ae1c1146105465782634b8e29731461050857826357969c88146102b8578263715018a61461025e5782638da5cb5b14610232578263bfa1a890146101a6578263f2fde38b146100d457505063f5537ede1461007b57600080fd5b346100d15760603660031901126100d157610094610672565b6024356001600160a01b03811681036100cc57604435906100b361078f565b816100bc578380f35b6100c5926107e7565b3880808380f35b600080fd5b80fd5b909150346101a25760203660031901126101a2576100f0610672565b906100f961078f565b6001600160a01b03918216928315610150575050600054826bffffffffffffffffffffffff60a01b821617600055167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0600080a380f35b906020608492519162461bcd60e51b8352820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152fd5b8280fd5b9150346101a257806003193601126101a2576101c0610672565b6024359262ffffff841680940361022e576101d961078f565b612710841161020557506001600160a01b0316835260016020528220805462ffffff1916909117905580f35b60649083519062461bcd60e51b8252602081830152602482015263562d464560e01b6044820152fd5b8480fd5b83823461025a578160031936011261025a57905490516001600160a01b039091168152602090f35b5080fd5b83346100d157806003193601126100d15761027761078f565b600080546001600160a01b0319811682556001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a380f35b909150346101a25760603660031901126101a2576102d4610672565b60249182356044359367ffffffffffffffff92838611610504573660238701121561050457858101359284841161050057368385890101116105005761031861078f565b809661032387610718565b9182106104f7575b89958a8915159687610449575b333b1561025a5760848b828b938f8b9051988996879563d623439360e01b87528d870152828601526060604486015282606486015201848401378181018301859052601f01601f1916810103018183335af1801561043f5761041a575b50506103a086610718565b106103f25750506103af578480f35b836060937fd484ef0f7d7628a59a68ac61d0f72688997f1e503c87fe122563d259dbba68e795519360018060a01b031684526020840152820152a1388080808480f35b865162461bcd60e51b81526020828201529182015263158b519360e21b604482015260649150fd5b819a929a1161042d578852973880610395565b50634e487b7160e01b81526041909152fd5b8a513d8d823e3d90fd5b6001600160a01b038a168d5260016020528b8d20549498509362ffffff9150811680156104d0575b1696620f4240610481898c6108c1565b988b096104b8575b876104958b338c6107e7565b81018091116104a6578b9093610338565b634e487b7160e01b8c5260118552858cfd5b966000198110156104cc5760010196610489565b8b80fd5b507f0000000000000000000000000000000000000000000000000000000000001af4610471565b9650809661032b565b8880fd5b8780fd5b83823461025a57602036600319011261025a5760209162ffffff9082906001600160a01b03610535610672565b168152600185522054169051908152f35b83346100d15760208060031936011261025a5782359167ffffffffffffffff80841161025a573660238501121561025a578385013590811161025a576024906005953660248360051b8801011161066e576105a6829897969495986106c0565b936105b388519586610688565b8285526105bf836106c0565b858a019790601f1901368937865b8481106106155750505050505083519485948186019282875251809352850193925b8281106105fe57505050500390f35b8351855286955093810193928101926001016105ef565b989997989597969580821b8381018701356001600160a01b03811681036105005761063f90610718565b908a5183101561065c578a018901529699989795966001016105cd565b634e487b7160e01b8952603286528789fd5b8380fd5b600435906001600160a01b03821682036100cc57565b90601f8019910116810190811067ffffffffffffffff8211176106aa57604052565b634e487b7160e01b600052604160045260246000fd5b67ffffffffffffffff81116106aa5760051b60200190565b3d15610713573d9067ffffffffffffffff82116106aa5760405191610707601f8201601f191660200184610688565b82523d6000602084013e565b606090565b60405160208101906370a0823160e01b8252306024820152602481526060810181811067ffffffffffffffff8211176106aa576040526000928392839251915afa906107626106d8565b9180610783575b156100d1576020828051810103126100d157506020015190565b50602082511015610769565b6000546001600160a01b031633036107a357565b606460405162461bcd60e51b815260206004820152602060248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152fd5b60405163a9059cbb60e01b602082019081526001600160a01b039093166024820152604480820194909452928352916080810167ffffffffffffffff8111828210176106aa57604052600092839283809351925af1906108456106d8565b9082610880575b50501561085557565b606460405162461bcd60e51b815260206004820152600460248201526315cb54d560e21b6044820152fd5b908092505191821592831561089a575b505050388061084c565b81929350906020918101031261025a57602001519081151582036100d15750388080610890565b9080820290600019818409908280831092039082820392620f424092848411156100cc5714610920577fde8f6cefed634549b62c77574f722e1ac57e23f24d8fd5cb790fb65668c26139940990828211900360fa1b910360061c170290565b50925050049056fea2646970667358221220358c986140634f9ebc7a8ddd405fc318fb12b6581496ea718f8ac8798111436164736f6c63430008170033

0000000000000000000000000000000000000000000000000000000000001af4

-----Decoded View---------------
Arg [0] : _defaultFlashFee (uint24): 6900

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000001af4