Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import "./interfaces/AggregatorV3Interface.sol";

import "./BaseRateProviderFactory.sol";
import "./ChainlinkRateProvider.sol";

/**
 * @title Chainlink Rate Provider Factory
 * @notice Factory for creating ChainlinkRateProviders
 * @dev This contract is used to create ChainlinkRateProvider contracts.
 *      RateProviders created by this factory are to be used in environments
 *      where the Chainlink registry is not available.
 */
contract ChainlinkRateProviderFactory is BaseRateProviderFactory {
    /**
     * @notice Deploys a new ChainlinkRateProvider contract using a price feed.
     * @param feed - The Chainlink price feed contract.
     */
    function create(AggregatorV3Interface feed) external returns (ChainlinkRateProvider) {
        ChainlinkRateProvider rateProvider = new ChainlinkRateProvider(feed);
        _onCreate(address(rateProvider));
        return rateProvider;
    }
}

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

interface AggregatorV3Interface {

  function decimals()
    external
    view
    returns (
      uint8
    );

  function description()
    external
    view
    returns (
      string memory
    );

  function version()
    external
    view
    returns (
      uint256
    );

  // getRoundData and latestRoundData should both raise "No data present"
  // if they do not have data to report, instead of returning unset values
  // which could be misinterpreted as actual reported values.
  function getRoundData(
    uint80 _roundId
  )
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

  function latestRoundData()
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

}

// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import "./interfaces/IBaseRateProviderFactory.sol";

/**
 * @title Base Rate Provider Factory
 * @notice Base Factory for creating RateProviders
 * @dev This is a base contract for building factories that create RateProviders.
 */
contract BaseRateProviderFactory is IBaseRateProviderFactory {
    // Mapping of rate providers created by this factory.
    mapping(address => bool) private _isRateProviderFromFactory;

    event RateProviderCreated(address indexed rateProvider);

    function isRateProviderFromFactory(address rateProvider) external view returns (bool) {
        return _isRateProviderFromFactory[rateProvider];
    }

    function _onCreate(address rateProvider) internal {
        _isRateProviderFromFactory[rateProvider] = true;
        emit RateProviderCreated(rateProvider);
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

import "./interfaces/AggregatorV3Interface.sol";
import "./interfaces/FeedRegistryInterface.sol";
import "openzeppelin-contracts/utils/math/SafeMath.sol";

import "./interfaces/IRateProvider.sol";

/**
 * @title Chainlink Rate Provider
 * @notice Returns a Chainlink price feed's quote for the provided currency pair
 * @dev This rate provider is a simplification of ChainlinkReistryRateProvider which is fixed to a particular pricefeed.
 *      This is expected to be used in environments where the Chainlink registry is not available.
 */
contract ChainlinkRateProvider is IRateProvider {
    AggregatorV3Interface public immutable pricefeed;

    // Rate providers are expected to respond with a fixed-point value with 18 decimals
    // We then need to scale the price feed's output to match this.
    uint256 internal immutable _scalingFactor;

    /**
     * @param feed - The Chainlink price feed contract
     */
    constructor(AggregatorV3Interface feed) {
        pricefeed = feed;
        _scalingFactor = 10 ** SafeMath.sub(18, feed.decimals());
    }

    /**
     * @return the value of the quote currency in terms of the base currency
     */
    function getRate() external view override returns (uint256) {
        (, int256 price,,,) = pricefeed.latestRoundData();
        require(price > 0, "Invalid price rate response");
        return uint256(price) * _scalingFactor;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

interface IBaseRateProviderFactory {
    /**
     * @dev Checks if a rate provider was created by the derived factory.
     * @param rateProvider - Address of the rate provider to check.
     * @return bool - True if the rate provider was created by the derived factory.
     */
    function isRateProviderFromFactory(address rateProvider) external view returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma abicoder v2;

import "./AggregatorV2V3Interface.sol";

interface FeedRegistryInterface {
  struct Phase {
    uint16 phaseId;
    uint80 startingAggregatorRoundId;
    uint80 endingAggregatorRoundId;
  }

  event FeedProposed(
    address indexed asset,
    address indexed denomination,
    address indexed proposedAggregator,
    address currentAggregator,
    address sender
  );
  event FeedConfirmed(
    address indexed asset,
    address indexed denomination,
    address indexed latestAggregator,
    address previousAggregator,
    uint16 nextPhaseId,
    address sender
  );

  // V3 AggregatorV3Interface

  function decimals(
    address base,
    address quote
  )
    external
    view
    returns (
      uint8
    );

  function description(
    address base,
    address quote
  )
    external
    view
    returns (
      string memory
    );

  function version(
    address base,
    address quote
  )
    external
    view
    returns (
      uint256
    );

  function latestRoundData(
    address base,
    address quote
  )
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

  function getRoundData(
    address base,
    address quote,
    uint80 _roundId
  )
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

  // V2 AggregatorInterface

  function latestAnswer(
    address base,
    address quote
  )
    external
    view
    returns (
      int256 answer
    );

  function latestTimestamp(
    address base,
    address quote
  )
    external
    view
    returns (
      uint256 timestamp
    );

  function latestRound(
    address base,
    address quote
  )
    external
    view
    returns (
      uint256 roundId
    );

  function getAnswer(
    address base,
    address quote,
    uint256 roundId
  )
    external
    view
    returns (
      int256 answer
    );

  function getTimestamp(
    address base,
    address quote,
    uint256 roundId
  )
    external
    view
    returns (
      uint256 timestamp
    );

  // Registry getters

  function getFeed(
    address base,
    address quote
  )
    external
    view
    returns (
      AggregatorV2V3Interface aggregator
    );

  function getPhaseFeed(
    address base,
    address quote,
    uint16 phaseId
  )
    external
    view
    returns (
      AggregatorV2V3Interface aggregator
    );

  function isFeedEnabled(
    address aggregator
  )
    external
    view
    returns (
      bool
    );

  function getPhase(
    address base,
    address quote,
    uint16 phaseId
  )
    external
    view
    returns (
      Phase memory phase
    );

  // Round helpers

  function getRoundFeed(
    address base,
    address quote,
    uint80 roundId
  )
    external
    view
    returns (
      AggregatorV2V3Interface aggregator
    );

  function getPhaseRange(
    address base,
    address quote,
    uint16 phaseId
  )
    external
    view
    returns (
      uint80 startingRoundId,
      uint80 endingRoundId
    );

  function getPreviousRoundId(
    address base,
    address quote,
    uint80 roundId
  ) external
    view
    returns (
      uint80 previousRoundId
    );

  function getNextRoundId(
    address base,
    address quote,
    uint80 roundId
  ) external
    view
    returns (
      uint80 nextRoundId
    );

  // Feed management

  function proposeFeed(
    address base,
    address quote,
    address aggregator
  ) external;

  function confirmFeed(
    address base,
    address quote,
    address aggregator
  ) external;

  // Proposed aggregator

  function getProposedFeed(
    address base,
    address quote
  )
    external
    view
    returns (
      AggregatorV2V3Interface proposedAggregator
    );

  function proposedGetRoundData(
    address base,
    address quote,
    uint80 roundId
  )
    external
    view
    returns (
      uint80 id,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

  function proposedLatestRoundData(
    address base,
    address quote
  )
    external
    view
    returns (
      uint80 id,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

  // Phases
  function getCurrentPhaseId(
    address base,
    address quote
  )
    external
    view
    returns (
      uint16 currentPhaseId
    );
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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 addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

// TODO: pull this from the monorepo
interface IRateProvider {
    function getRate() external view returns (uint256);
}

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

import "./AggregatorInterface.sol";
import "./AggregatorV3Interface.sol";

interface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface {}

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

interface AggregatorInterface {
  function latestAnswer()
    external
    view
    returns (
      int256
    );
  
  function latestTimestamp()
    external
    view
    returns (
      uint256
    );

  function latestRound()
    external
    view
    returns (
      uint256
    );

  function getAnswer(
    uint256 roundId
  )
    external
    view
    returns (
      int256
    );

  function getTimestamp(
    uint256 roundId
  )
    external
    view
    returns (
      uint256
    );

  event AnswerUpdated(
    int256 indexed current,
    uint256 indexed roundId,
    uint256 updatedAt
  );

  event NewRound(
    uint256 indexed roundId,
    address indexed startedBy,
    uint256 startedAt
  );
}

{
  "remappings": [
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/"
  ],
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"rateProvider","type":"address"}],"name":"RateProviderCreated","type":"event"},{"inputs":[{"internalType":"contract AggregatorV3Interface","name":"feed","type":"address"}],"name":"create","outputs":[{"internalType":"contract ChainlinkRateProvider","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"rateProvider","type":"address"}],"name":"isRateProviderFromFactory","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

6080604052348015600e575f5ffd5b50610c8a8061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c806319912f71146100385780639ed9331814610068575b5f5ffd5b610052600480360381019061004d9190610235565b610098565b60405161005f919061027a565b60405180910390f35b610082600480360381019061007d91906102ce565b6100e9565b60405161008f9190610354565b60405180910390f35b5f5f5f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff169050919050565b5f5f826040516100f8906101ca565b610102919061038d565b604051809103905ff08015801561011b573d5f5f3e3d5ffd5b50905061012781610130565b80915050919050565b60015f5f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff0219169083151502179055508073ffffffffffffffffffffffffffffffffffffffff167f7a8e6b463d413484480a3a8120e5fb841491c52541ac3f649ac41d9b0d088aa660405160405180910390a250565b6108ae806103a783390190565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f610204826101db565b9050919050565b610214816101fa565b811461021e575f5ffd5b50565b5f8135905061022f8161020b565b92915050565b5f6020828403121561024a576102496101d7565b5b5f61025784828501610221565b91505092915050565b5f8115159050919050565b61027481610260565b82525050565b5f60208201905061028d5f83018461026b565b92915050565b5f61029d826101fa565b9050919050565b6102ad81610293565b81146102b7575f5ffd5b50565b5f813590506102c8816102a4565b92915050565b5f602082840312156102e3576102e26101d7565b5b5f6102f0848285016102ba565b91505092915050565b5f819050919050565b5f61031c610317610312846101db565b6102f9565b6101db565b9050919050565b5f61032d82610302565b9050919050565b5f61033e82610323565b9050919050565b61034e81610334565b82525050565b5f6020820190506103675f830184610345565b92915050565b5f61037782610323565b9050919050565b6103878161036d565b82525050565b5f6020820190506103a05f83018461037e565b9291505056fe60c060405234801561000f575f5ffd5b506040516108ae3803806108ae83398181016040528101906100319190610182565b8073ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff16815250506100e560128273ffffffffffffffffffffffffffffffffffffffff1663313ce5676040518163ffffffff1660e01b8152600401602060405180830381865afa1580156100b3573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906100d791906101e3565b60ff166100fe60201b60201c565b600a6100f19190610373565b60a08181525050506103f0565b5f818361010b91906103bd565b905092915050565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61014082610117565b9050919050565b5f61015182610136565b9050919050565b61016181610147565b811461016b575f5ffd5b50565b5f8151905061017c81610158565b92915050565b5f6020828403121561019757610196610113565b5b5f6101a48482850161016e565b91505092915050565b5f60ff82169050919050565b6101c2816101ad565b81146101cc575f5ffd5b50565b5f815190506101dd816101b9565b92915050565b5f602082840312156101f8576101f7610113565b5b5f610205848285016101cf565b91505092915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f8160011c9050919050565b5f5f8291508390505b60018511156102905780860481111561026c5761026b61020e565b5b600185161561027b5780820291505b80810290506102898561023b565b9450610250565b94509492505050565b5f826102a85760019050610363565b816102b5575f9050610363565b81600181146102cb57600281146102d557610304565b6001915050610363565b60ff8411156102e7576102e661020e565b5b8360020a9150848211156102fe576102fd61020e565b5b50610363565b5060208310610133831016604e8410600b84101617156103395782820a9050838111156103345761033361020e565b5b610363565b6103468484846001610247565b9250905081840481111561035d5761035c61020e565b5b81810290505b9392505050565b5f819050919050565b5f61037d8261036a565b91506103888361036a565b92506103b57fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8484610299565b905092915050565b5f6103c78261036a565b91506103d28361036a565b92508282039050818111156103ea576103e961020e565b5b92915050565b60805160a0516104986104165f395f61017101525f818160760152609c01526104985ff3fe608060405234801561000f575f5ffd5b5060043610610034575f3560e01c8063590f211314610038578063679aefce14610056575b5f5ffd5b610040610074565b60405161004d919061021b565b60405180910390f35b61005e610098565b60405161006b919061024c565b60405180910390f35b7f000000000000000000000000000000000000000000000000000000000000000081565b5f5f7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663feaf968c6040518163ffffffff1660e01b815260040160a060405180830381865afa158015610103573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906101279190610305565b5050509150505f811361016f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610166906103d6565b60405180910390fd5b7f00000000000000000000000000000000000000000000000000000000000000008161019b9190610421565b91505090565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f819050919050565b5f6101e36101de6101d9846101a1565b6101c0565b6101a1565b9050919050565b5f6101f4826101c9565b9050919050565b5f610205826101ea565b9050919050565b610215816101fb565b82525050565b5f60208201905061022e5f83018461020c565b92915050565b5f819050919050565b61024681610234565b82525050565b5f60208201905061025f5f83018461023d565b92915050565b5f5ffd5b5f69ffffffffffffffffffff82169050919050565b61028781610269565b8114610291575f5ffd5b50565b5f815190506102a28161027e565b92915050565b5f819050919050565b6102ba816102a8565b81146102c4575f5ffd5b50565b5f815190506102d5816102b1565b92915050565b6102e481610234565b81146102ee575f5ffd5b50565b5f815190506102ff816102db565b92915050565b5f5f5f5f5f60a0868803121561031e5761031d610265565b5b5f61032b88828901610294565b955050602061033c888289016102c7565b945050604061034d888289016102f1565b935050606061035e888289016102f1565b925050608061036f88828901610294565b9150509295509295909350565b5f82825260208201905092915050565b7f496e76616c6964207072696365207261746520726573706f6e736500000000005f82015250565b5f6103c0601b8361037c565b91506103cb8261038c565b602082019050919050565b5f6020820190508181035f8301526103ed816103b4565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61042b82610234565b915061043683610234565b925082820261044481610234565b9150828204841483151761045b5761045a6103f4565b5b509291505056fea2646970667358221220111f12aecf9ac149161384507a34d8a0c64677458af79300d7ff03584e9ee5ef64736f6c634300081c0033a2646970667358221220f4ccb8e6da37cc90a7acf7bd6dc1458a12819580f30f34a0c9bb0e1b1544688164736f6c634300081c0033

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