Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• library SignedMath
•    - function max(int256 a, int256 b)
•    - function min(int256 a, int256 b)
•    - function average(int256 a, int256 b)
•    - function abs(int256 n)
• library Math
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
•    - function unsignedRoundsUp(Rounding ro ...
• library Strings
•    - function toString(uint256 value)
•    - function toStringSigned(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function equal(string memory a, strin ...
• interface IBlastPoints
•    - function configurePointsOperator(addr ...
• interface IBlast
•    - function configureClaimableYield()
•    - function configureGovernor(address _g ...
•    - function claimYield(address contractA ...
•    - function claimAllYield(address contra ...
•    - function readClaimableYield(address c ...
• interface IERC20Rebasing
•    - function configure(YieldMode mode)
•    - function claim(address recipient, uin ...
•    - function getClaimableAmount(address a ...
•  contract PacBotProxy *
•    - function multicall(Call[] memory call ...
•    - function depositEth()
•    - function depositUsdb(uint256 amount)
•    - function withdrawEth(uint256 amount)
•    - function withdrawUsdb(uint256 amount)
•    - function claimEthYield(address recipi ...
•    - function claimAllEthYield(address rec ...
•    - function claimUsdbYield(address recip ...
•    - function readClaimableEthYield()
•    - function readClaimableUsdbYield(addre ...
•    - function balanceOfEth(address recipie ...
•    - function balanceOfUsdb(address recipi ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at blastscan.io on 2024-03-01
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.19;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // 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 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            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 for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the 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.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // 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 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;



/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// File: contracts/1_Storage.sol


pragma solidity ^0.8.19;



enum YieldMode {
    AUTOMATIC,
    VOID,
    CLAIMABLE
}

interface IBlastPoints {
    function configurePointsOperator(address operator) external;
}

interface IBlast {
    function configureClaimableYield() external;
    function configureGovernor(address _governor) external;
    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);
    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);
    function readClaimableYield(address contractAddress) external view returns (uint256);
}

interface IERC20Rebasing {
    function configure(YieldMode mode) external returns (uint256);
    function claim(address recipient, uint256 amount) external returns (uint256);
    function getClaimableAmount(address account) external view returns (uint256);
}

contract PacBotProxy {
    struct Call {
        address target;
        bytes data;
    }

    // address BlastPointsTestnet = 0x2fc95838c71e76ec69ff817983BFf17c710F34E0;
    address BlastYield = 0x4300000000000000000000000000000000000002;
    address RebasingUsdb = 0x4300000000000000000000000000000000000003;
    address owner = 0xc0a1418E5f29A0106790A98E95Bb9f7AAC4F4471;

    mapping(address => uint256) public balancesOfEth;
    mapping(address => uint256) public balancesOfUsdb;

    constructor() {
        // IBlastPoints(BlastPointsTestnet).configurePointsOperator(0xc0a1418E5f29A0106790A98E95Bb9f7AAC4F4471);
        IBlast(BlastYield).configureClaimableYield();
        IBlast(BlastYield).configureGovernor(0xc0a1418E5f29A0106790A98E95Bb9f7AAC4F4471);
        IERC20Rebasing(RebasingUsdb).configure(YieldMode.CLAIMABLE);
    }

    function multicall(Call[] memory calls) public payable returns (bytes[] memory) {
        bytes[] memory results = new bytes[](calls.length);

        for (uint256 i = 0; i < calls.length; i++) {
            (bool success, bytes memory result) = calls[i].target.call{value: msg.value}(calls[i].data);

            require(success, string.concat("Call failed ", Strings.toString(i)));
            results[i] = result;
        }

        return results;
    }

    function depositEth() external payable {
        balancesOfEth[msg.sender] += msg.value;
    }

    function depositUsdb(uint256 amount) external {
        require(amount > 0);

        uint256 balanceBefore = IERC20(RebasingUsdb).balanceOf(msg.sender);
        require(balanceBefore >= amount);

        IERC20(RebasingUsdb).transferFrom(msg.sender, address(this), amount);

        uint256 balanceAfter = IERC20(RebasingUsdb).balanceOf(msg.sender);
        require(balanceAfter == balanceBefore - amount);

        balancesOfUsdb[msg.sender] += amount;
    }

    function withdrawEth(uint256 amount) external {
        require(balancesOfEth[msg.sender] >= amount);

        payable(msg.sender).transfer(amount);
        balancesOfEth[msg.sender] -= amount;
    }

    function withdrawUsdb(uint256 amount) external {
        require(balancesOfUsdb[msg.sender] >= amount);

        IERC20(RebasingUsdb).transfer(msg.sender, amount);
        balancesOfUsdb[msg.sender] -= amount;
    }

    function claimEthYield(address recipient, uint256 amount) external {
        require(msg.sender == owner);

        IBlast(BlastYield).claimYield(address(this), recipient, amount);
    }

    function claimAllEthYield(address recipient) external {
        require(msg.sender == owner);

        IBlast(BlastYield).claimAllYield(address(this), recipient);
    }

    function claimUsdbYield(address recipient, uint256 amount) external returns (uint256) {
        require(msg.sender == owner);

        return IERC20Rebasing(RebasingUsdb).claim(recipient, amount);
    }

    function readClaimableEthYield() external view returns (uint256) {
        return IBlast(BlastYield).readClaimableYield(address(this));
    }

    function readClaimableUsdbYield(address recipient) external view returns (uint256) {
        return IERC20Rebasing(RebasingUsdb).getClaimableAmount(recipient);
    }

    function balanceOfEth(address recipient) external view returns (uint256) {
        return balancesOfEth[recipient];
    }

    function balanceOfUsdb(address recipient) external view returns (uint256) {
        return balancesOfUsdb[recipient];
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"balanceOfEth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"balanceOfUsdb","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balancesOfEth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balancesOfUsdb","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"claimAllEthYield","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimEthYield","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimUsdbYield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositEth","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositUsdb","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct PacBotProxy.Call[]","name":"calls","type":"tuple[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"readClaimableEthYield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"readClaimableUsdbYield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawUsdb","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

23871:3542:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26236:190;;;;;;;;;;-1:-1:-1;26236:190:0;;;;;:::i;:::-;;:::i;:::-;;27154:123;;;;;;;;;;-1:-1:-1;27154:123:0;;;;;:::i;:::-;-1:-1:-1;;;;;27245:24:0;27218:7;27245:24;;;:13;:24;;;;;;;27154:123;;;;788:25:1;;;776:2;761:18;27154:123:0;;;;;;;;25212:96;;;:::i;26614:206::-;;;;;;;;;;-1:-1:-1;26614:206:0;;;;;:::i;:::-;;:::i;26434:172::-;;;;;;;;;;-1:-1:-1;26434:172:0;;;;;:::i;:::-;;:::i;26008:220::-;;;;;;;;;;-1:-1:-1;26008:220:0;;;;;:::i;:::-;;:::i;27285:125::-;;;;;;;;;;-1:-1:-1;27285:125:0;;;;;:::i;:::-;-1:-1:-1;;;;;27377:25:0;27350:7;27377:25;;;:14;:25;;;;;;;27285:125;26979:167;;;;;;;;;;-1:-1:-1;26979:167:0;;;;;:::i;:::-;;:::i;25796:204::-;;;;;;;;;;-1:-1:-1;25796:204:0;;;;;:::i;:::-;;:::i;26828:143::-;;;;;;;;;;;;;:::i;24736:468::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;24263:48::-;;;;;;;;;;-1:-1:-1;24263:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;24318:49;;;;;;;;;;-1:-1:-1;24318:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;25316:472;;;;;;;;;;-1:-1:-1;25316:472:0;;;;;:::i;:::-;;:::i;26236:190::-;26336:5;;-1:-1:-1;;;;;26336:5:0;26322:10;:19;26314:28;;;;;;26362:10;;26355:63;;-1:-1:-1;;;26355:63:0;;26393:4;26355:63;;;5591:34:1;-1:-1:-1;;;;;5661:15:1;;;5641:18;;;5634:43;5693:18;;;5686:34;;;26362:10:0;;;;26355:29;;5526:18:1;;26355:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;26236:190;;:::o;25212:96::-;25276:10;25262:25;;;;:13;:25;;;;;:38;;25291:9;;25262:25;:38;;25291:9;;25262:38;:::i;:::-;;;;-1:-1:-1;;25212:96:0:o;26614:206::-;26733:5;;26691:7;;-1:-1:-1;;;;;26733:5:0;26719:10;:19;26711:28;;;;;;26774:12;;26759:53;;-1:-1:-1;;;26759:53:0;;-1:-1:-1;;;;;6374:32:1;;;26759:53:0;;;6356:51:1;6423:18;;;6416:34;;;26774:12:0;;;;26759:34;;6329:18:1;;26759:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26752:60;;26614:206;;;;;:::o;26434:172::-;26521:5;;-1:-1:-1;;;;;26521:5:0;26507:10;:19;26499:28;;;;;;26547:10;;26540:58;;-1:-1:-1;;;26540:58:0;;26581:4;26540:58;;;6673:34:1;-1:-1:-1;;;;;6743:15:1;;;6723:18;;;6716:43;26547:10:0;;;;26540:32;;6608:18:1;;26540:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;26434:172;:::o;26008:220::-;26089:10;26074:26;;;;:14;:26;;;;;;:36;-1:-1:-1;26074:36:0;26066:45;;;;;;26131:12;;26124:49;;-1:-1:-1;;;26124:49:0;;26154:10;26124:49;;;6356:51:1;6423:18;;;6416:34;;;-1:-1:-1;;;;;26131:12:0;;;;26124:29;;6329:18:1;;26124:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;26199:10:0;26184:26;;;;:14;:26;;;;;:36;;26214:6;;26184:26;:36;;26214:6;;26184:36;:::i;:::-;;;;-1:-1:-1;;;26008:220:0:o;26979:167::-;27095:12;;27080:58;;-1:-1:-1;;;27080:58:0;;-1:-1:-1;;;;;7349:32:1;;;27080:58:0;;;7331:51:1;27053:7:0;;27095:12;;27080:47;;7304:18:1;;27080:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;25796:204::-;25875:10;25861:25;;;;:13;:25;;;;;;:35;-1:-1:-1;25861:35:0;25853:44;;;;;;25910:36;;25918:10;;25910:36;;;;;25939:6;;25910:36;;;;25939:6;25918:10;25910:36;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25971:10:0;25957:25;;;;:13;:25;;;;;:35;;25986:6;;25957:25;:35;;25986:6;;25957:35;:::i;26828:143::-;26884:7;26918:10;;26911:52;;-1:-1:-1;;;26911:52:0;;26957:4;26911:52;;;7331:51:1;-1:-1:-1;;;;;26918:10:0;;;;26911:37;;7304:18:1;;26911:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26904:59;;26828:143;:::o;24736:468::-;24800:14;24827:22;24864:5;:12;24852:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24827:50;;24895:9;24890:280;24914:5;:12;24910:1;:16;24890:280;;;24949:12;24963:19;24986:5;24992:1;24986:8;;;;;;;;:::i;:::-;;;;;;;:15;;;-1:-1:-1;;;;;24986:20:0;25014:9;25025:5;25031:1;25025:8;;;;;;;;:::i;:::-;;;;;;;:13;;;24986:53;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24948:91;;;;25064:7;25103:19;25120:1;25103:16;:19::i;:::-;25073:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;25056:68;;;;;-1:-1:-1;;;25056:68:0;;;;;;;;:::i;:::-;;;;;;;;;;25152:6;25139:7;25147:1;25139:10;;;;;;;;:::i;:::-;;;;;;;;;;:19;-1:-1:-1;;24928:3:0;;24890:280;;;-1:-1:-1;25189:7:0;24736:468;-1:-1:-1;;24736:468:0:o;25316:472::-;25390:1;25381:6;:10;25373:19;;;;;;25436:12;;25429:42;;-1:-1:-1;;;25429:42:0;;25460:10;25429:42;;;7331:51:1;25405:21:0;;-1:-1:-1;;;;;25436:12:0;;25429:30;;7304:18:1;;25429:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25405:66;;25507:6;25490:13;:23;;25482:32;;;;;;25534:12;;25527:68;;-1:-1:-1;;;25527:68:0;;25561:10;25527:68;;;5591:34:1;25581:4:0;5641:18:1;;;5634:43;5693:18;;;5686:34;;;-1:-1:-1;;;;;25534:12:0;;;;25527:33;;5526:18:1;;25527:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;25638:12:0;;25631:42;;-1:-1:-1;;;25631:42:0;;25662:10;25631:42;;;7331:51:1;25608:20:0;;-1:-1:-1;;;;;25638:12:0;;25631:30;;7304:18:1;;25631:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25608:65;-1:-1:-1;25708:22:0;25724:6;25708:13;:22;:::i;:::-;25692:12;:38;25684:47;;;;;;25759:10;25744:26;;;;:14;:26;;;;;:36;;25774:6;;25744:26;:36;;25774:6;;25744:36;:::i;:::-;;;;-1:-1:-1;;;;;25316:472:0:o;20383:718::-;20439:13;20490:14;20507:17;20518:5;20507:10;:17::i;:::-;20527:1;20507:21;20490:38;;20543:20;20577:6;20566:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20566:18:0;-1:-1:-1;20543:41:0;-1:-1:-1;20708:28:0;;;20724:2;20708:28;20765:290;-1:-1:-1;;20797:5:0;-1:-1:-1;;;20934:2:0;20923:14;;20918:32;20797:5;20905:46;20997:2;20988:11;;;-1:-1:-1;21018:21:0;20765:290;21018:21;-1:-1:-1;21076:6:0;20383:718;-1:-1:-1;;;20383:718:0:o;16787:948::-;16840:7;;-1:-1:-1;;;16918:17:0;;16914:106;;-1:-1:-1;;;16956:17:0;;;-1:-1:-1;17002:2:0;16992:12;16914:106;17047:8;17038:5;:17;17034:106;;17085:8;17076:17;;;-1:-1:-1;17122:2:0;17112:12;17034:106;17167:8;17158:5;:17;17154:106;;17205:8;17196:17;;;-1:-1:-1;17242:2:0;17232:12;17154:106;17287:7;17278:5;:16;17274:103;;17324:7;17315:16;;;-1:-1:-1;17360:1:0;17350:11;17274:103;17404:7;17395:5;:16;17391:103;;17441:7;17432:16;;;-1:-1:-1;17477:1:0;17467:11;17391:103;17521:7;17512:5;:16;17508:103;;17558:7;17549:16;;;-1:-1:-1;17594:1:0;17584:11;17508:103;17638:7;17629:5;:16;17625:68;;17676:1;17666:11;17721:6;16787:948;-1:-1:-1;;16787:948:0:o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;436:2;421:18;;;;408:32;;-1:-1:-1;;;192:254:1:o;451:186::-;510:6;563:2;551:9;542:7;538:23;534:32;531:52;;;579:1;576;569:12;531:52;602:29;621:9;602:29;:::i;824:180::-;883:6;936:2;924:9;915:7;911:23;907:32;904:52;;;952:1;949;942:12;904:52;-1:-1:-1;975:23:1;;824:180;-1:-1:-1;824:180:1:o;1009:127::-;1070:10;1065:3;1061:20;1058:1;1051:31;1101:4;1098:1;1091:15;1125:4;1122:1;1115:15;1141:257;1213:4;1207:11;;;1245:17;;1292:18;1277:34;;1313:22;;;1274:62;1271:88;;;1339:18;;:::i;:::-;1375:4;1368:24;1141:257;:::o;1403:275::-;1474:2;1468:9;1539:2;1520:13;;-1:-1:-1;;1516:27:1;1504:40;;1574:18;1559:34;;1595:22;;;1556:62;1553:88;;;1621:18;;:::i;:::-;1657:2;1650:22;1403:275;;-1:-1:-1;1403:275:1:o;1683:2328::-;1789:6;1820:2;1863;1851:9;1842:7;1838:23;1834:32;1831:52;;;1879:1;1876;1869:12;1831:52;1919:9;1906:23;1948:18;1989:2;1981:6;1978:14;1975:34;;;2005:1;2002;1995:12;1975:34;2043:6;2032:9;2028:22;2018:32;;2088:7;2081:4;2077:2;2073:13;2069:27;2059:55;;2110:1;2107;2100:12;2059:55;2146:2;2133:16;2168:2;2164;2161:10;2158:36;;;2174:18;;:::i;:::-;2220:2;2217:1;2213:10;2243:28;2267:2;2263;2259:11;2243:28;:::i;:::-;2305:15;;;2375:11;;;2371:20;;;2336:12;;;;2403:19;;;2400:39;;;2435:1;2432;2425:12;2400:39;2467:2;2463;2459:11;2448:22;;2479:1502;2495:6;2490:3;2487:15;2479:1502;;;2581:3;2568:17;2617:2;2604:11;2601:19;2598:109;;;2661:1;2690:2;2686;2679:14;2598:109;2730:20;;2773:4;-1:-1:-1;;2831:16:1;;;2827:25;;2823:34;-1:-1:-1;2820:127:1;;;2899:1;2929:3;2924;2917:16;2820:127;2973:22;;:::i;:::-;3022:31;3049:2;3045;3041:11;3022:31;:::i;:::-;3015:5;3008:46;3104:2;3100;3096:11;3083:25;3137:2;3127:8;3124:16;3121:109;;;3182:1;3212:3;3207;3200:16;3121:109;3262:8;3258:2;3254:17;3243:28;;;3312:7;3307:2;3302:3;3298:12;3294:26;3284:127;;3363:1;3393:3;3388;3381:16;3284:127;3457:2;3452:3;3448:12;3435:26;3485:2;3480:3;3477:11;3474:37;;;3491:18;;:::i;:::-;3537:49;3582:2;3577;3570:4;3565:3;3561:14;3557:23;3553:32;3537:49;:::i;:::-;3524:62;;3613:3;3606:5;3599:18;3660:7;3655:2;3649:3;3644;3640:13;3636:22;3633:35;3630:128;;;3710:1;3740:3;3735;3728:16;3630:128;3814:3;3809:2;3804:3;3800:12;3795:2;3788:5;3784:14;3771:47;3864:1;3842:15;;;3838:24;;3831:35;3886:14;;;3879:29;;;;3921:18;;-1:-1:-1;;2512:12:1;;;;3959;;;;2479:1502;;;4000:5;1683:2328;-1:-1:-1;;;;;;;;;1683:2328:1:o;4016:250::-;4101:1;4111:113;4125:6;4122:1;4119:13;4111:113;;;4201:11;;;4195:18;4182:11;;;4175:39;4147:2;4140:10;4111:113;;;-1:-1:-1;;4258:1:1;4240:16;;4233:27;4016:250::o;4271:270::-;4312:3;4350:5;4344:12;4377:6;4372:3;4365:19;4393:76;4462:6;4455:4;4450:3;4446:14;4439:4;4432:5;4428:16;4393:76;:::i;:::-;4523:2;4502:15;-1:-1:-1;;4498:29:1;4489:39;;;;4530:4;4485:50;;4271:270;-1:-1:-1;;4271:270:1:o;4546:800::-;4706:4;4735:2;4775;4764:9;4760:18;4805:2;4794:9;4787:21;4828:6;4863;4857:13;4894:6;4886;4879:22;4932:2;4921:9;4917:18;4910:25;;4994:2;4984:6;4981:1;4977:14;4966:9;4962:30;4958:39;4944:53;;5032:2;5024:6;5020:15;5053:1;5063:254;5077:6;5074:1;5071:13;5063:254;;;5170:2;5166:7;5154:9;5146:6;5142:22;5138:36;5133:3;5126:49;5198:39;5230:6;5221;5215:13;5198:39;:::i;:::-;5188:49;-1:-1:-1;5295:12:1;;;;5260:15;;;;5099:1;5092:9;5063:254;;;-1:-1:-1;5334:6:1;;4546:800;-1:-1:-1;;;;;;;4546:800:1:o;5731:184::-;5801:6;5854:2;5842:9;5833:7;5829:23;5825:32;5822:52;;;5870:1;5867;5860:12;5822:52;-1:-1:-1;5893:16:1;;5731:184;-1:-1:-1;5731:184:1:o;5920:127::-;5981:10;5976:3;5972:20;5969:1;5962:31;6012:4;6009:1;6002:15;6036:4;6033:1;6026:15;6052:125;6117:9;;;6138:10;;;6135:36;;;6151:18;;:::i;6770:277::-;6837:6;6890:2;6878:9;6869:7;6865:23;6861:32;6858:52;;;6906:1;6903;6896:12;6858:52;6938:9;6932:16;6991:5;6984:13;6977:21;6970:5;6967:32;6957:60;;7013:1;7010;7003:12;6957:60;7036:5;6770:277;-1:-1:-1;;;6770:277:1:o;7052:128::-;7119:9;;;7140:11;;;7137:37;;;7154:18;;:::i;7393:127::-;7454:10;7449:3;7445:20;7442:1;7435:31;7485:4;7482:1;7475:15;7509:4;7506:1;7499:15;7525:287;7654:3;7692:6;7686:13;7708:66;7767:6;7762:3;7755:4;7747:6;7743:17;7708:66;:::i;:::-;7790:16;;;;;7525:287;-1:-1:-1;;7525:287:1:o;7817:434::-;-1:-1:-1;;;8064:3:1;8057:27;8039:3;8113:6;8107:13;8129:75;8197:6;8192:2;8187:3;8183:12;8176:4;8168:6;8164:17;8129:75;:::i;:::-;8224:16;;;;8242:2;8220:25;;7817:434;-1:-1:-1;;7817:434:1:o;8256:219::-;8405:2;8394:9;8387:21;8368:4;8425:44;8465:2;8454:9;8450:18;8442:6;8425:44;:::i

ipfs://2ea8b9060ae2135ef46f2b824194f17cf44c47dc439fb62b822135a7dbc885df