ref

.deps/npm/@openzeppelin/contracts/token/ERC20/IERC20.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.7.0;
+
+/**
+ * @dev Interface of the ERC20 standard as defined in the EIP.
+ */
+interface IERC20 {
+    /**
+     * @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 `recipient`.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    /**
+     * @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);
+}

.deps/npm/@uniswap/v3-core/contracts/libraries/LowGasSafeMath.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.7.0;
+
+/// @title Optimized overflow and underflow safe math operations
+/// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
+library LowGasSafeMath {
+    /// @notice Returns x + y, reverts if sum overflows uint256
+    /// @param x The augend
+    /// @param y The addend
+    /// @return z The sum of x and y
+    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        require((z = x + y) >= x);
+    }
+
+    /// @notice Returns x - y, reverts if underflows
+    /// @param x The minuend
+    /// @param y The subtrahend
+    /// @return z The difference of x and y
+    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        require((z = x - y) <= x);
+    }
+
+    /// @notice Returns x * y, reverts if overflows
+    /// @param x The multiplicand
+    /// @param y The multiplier
+    /// @return z The product of x and y
+    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        require(x == 0 || (z = x * y) / x == y);
+    }
+
+    /// @notice Returns x + y, reverts if overflows or underflows
+    /// @param x The augend
+    /// @param y The addend
+    /// @return z The sum of x and y
+    function add(int256 x, int256 y) internal pure returns (int256 z) {
+        require((z = x + y) >= x == (y >= 0));
+    }
+
+    /// @notice Returns x - y, reverts if overflows or underflows
+    /// @param x The minuend
+    /// @param y The subtrahend
+    /// @return z The difference of x and y
+    function sub(int256 x, int256 y) internal pure returns (int256 z) {
+        require((z = x - y) <= x == (y >= 0));
+    }
+}

.github/workflows/webpack.yml

@@ -0,0 +1,28 @@
+name: NodeJS with Webpack
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x, 22.x]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Build
+      run: |
+        npm install
+        npx webpack

FlashloanAttacker(copy)/contracts/dependencies/gnosis/contracts/GPv2SafeERC20.sol

@@ -0,0 +1,130 @@
+/*
+
+   ██████  ██████   ██████  ██   ██ ██████   ██████   ██████  ██   ██    ██████  ███████ ██    ██
+  ██      ██    ██ ██    ██ ██  ██  ██   ██ ██    ██ ██    ██ ██  ██     ██   ██ ██      ██    ██
+  ██      ██    ██ ██    ██ █████   ██████  ██    ██ ██    ██ █████      ██   ██ █████   ██    ██
+  ██      ██    ██ ██    ██ ██  ██  ██   ██ ██    ██ ██    ██ ██  ██     ██   ██ ██       ██  ██
+   ██████  ██████   ██████  ██   ██ ██████   ██████   ██████  ██   ██ ██ ██████  ███████   ████
+
+  Find any smart contract, and build your project faster: https://www.cookbook.dev
+  Twitter: https://twitter.com/cookbook_dev
+  Discord: https://discord.gg/cookbookdev
+
+  Find this contract on Cookbook: https://www.cookbook.dev/contracts/FlashloanAttacker?utm=code
+  */
+
+  // SPDX-License-Identifier: LGPL-3.0-or-later
+pragma solidity 0.8.10;
+
+import {IERC20} from '../../openzeppelin/contracts/IERC20.sol';
+
+/// @title Gnosis Protocol v2 Safe ERC20 Transfer Library
+/// @author Gnosis Developers
+/// @dev Gas-efficient version of Openzeppelin's SafeERC20 contract.
+library GPv2SafeERC20 {
+  /// @dev Wrapper around a call to the ERC20 function `transfer` that reverts
+  /// also when the token returns `false`.
+  function safeTransfer(IERC20 token, address to, uint256 value) internal {
+    bytes4 selector_ = token.transfer.selector;
+
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      let freeMemoryPointer := mload(0x40)
+      mstore(freeMemoryPointer, selector_)
+      mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff))
+      mstore(add(freeMemoryPointer, 36), value)
+
+      if iszero(call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)) {
+        returndatacopy(0, 0, returndatasize())
+        revert(0, returndatasize())
+      }
+    }
+
+    require(getLastTransferResult(token), 'GPv2: failed transfer');
+  }
+
+  /// @dev Wrapper around a call to the ERC20 function `transferFrom` that
+  /// reverts also when the token returns `false`.
+  function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
+    bytes4 selector_ = token.transferFrom.selector;
+
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      let freeMemoryPointer := mload(0x40)
+      mstore(freeMemoryPointer, selector_)
+      mstore(add(freeMemoryPointer, 4), and(from, 0xffffffffffffffffffffffffffffffffffffffff))
+      mstore(add(freeMemoryPointer, 36), and(to, 0xffffffffffffffffffffffffffffffffffffffff))
+      mstore(add(freeMemoryPointer, 68), value)
+
+      if iszero(call(gas(), token, 0, freeMemoryPointer, 100, 0, 0)) {
+        returndatacopy(0, 0, returndatasize())
+        revert(0, returndatasize())
+      }
+    }
+
+    require(getLastTransferResult(token), 'GPv2: failed transferFrom');
+  }
+
+  /// @dev Verifies that the last return was a successful `transfer*` call.
+  /// This is done by checking that the return data is either empty, or
+  /// is a valid ABI encoded boolean.
+  function getLastTransferResult(IERC20 token) private view returns (bool success) {
+    // NOTE: Inspecting previous return data requires assembly. Note that
+    // we write the return data to memory 0 in the case where the return
+    // data size is 32, this is OK since the first 64 bytes of memory are
+    // reserved by Solidy as a scratch space that can be used within
+    // assembly blocks.
+    // <https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html>
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      /// @dev Revert with an ABI encoded Solidity error with a message
+      /// that fits into 32-bytes.
+      ///
+      /// An ABI encoded Solidity error has the following memory layout:
+      ///
+      /// ------------+----------------------------------
+      ///  byte range | value
+      /// ------------+----------------------------------
+      ///  0x00..0x04 |        selector("Error(string)")
+      ///  0x04..0x24 |      string offset (always 0x20)
+      ///  0x24..0x44 |                    string length
+      ///  0x44..0x64 | string value, padded to 32-bytes
+      function revertWithMessage(length, message) {
+        mstore(0x00, '\x08\xc3\x79\xa0')
+        mstore(0x04, 0x20)
+        mstore(0x24, length)
+        mstore(0x44, message)
+        revert(0x00, 0x64)
+      }
+
+      switch returndatasize()
+      // Non-standard ERC20 transfer without return.
+      case 0 {
+        // NOTE: When the return data size is 0, verify that there
+        // is code at the address. This is done in order to maintain
+        // compatibility with Solidity calling conventions.
+        // <https://docs.soliditylang.org/en/v0.7.6/control-structures.html#external-function-calls>
+        if iszero(extcodesize(token)) {
+          revertWithMessage(20, 'GPv2: not a contract')
+        }
+
+        success := 1
+      }
+      // Standard ERC20 transfer returning boolean success value.
+      case 32 {
+        returndatacopy(0, 0, returndatasize())
+
+        // NOTE: For ABI encoding v1, any non-zero value is accepted
+        // as `true` for a boolean. In order to stay compatible with
+        // OpenZeppelin's `SafeERC20` library which is known to work
+        // with the existing ERC20 implementation we care about,
+        // make sure we return success for any non-zero return value
+        // from the `transfer*` call.
+        success := iszero(iszero(mload(0)))
+      }
+      default {
+        revertWithMessage(31, 'GPv2: malformed transfer result')
+      }
+    }
+  }
+}