文件 1 的 32：BalancerErrors.sol
pragma solidity ^0.7.0;
function _require(bool condition, uint256 errorCode) pure {
if (!condition) _revert(errorCode);
}
function _revert(uint256 errorCode) pure {
assembly {
let units := add(mod(errorCode, 10), 0x30)
errorCode := div(errorCode, 10)
let tenths := add(mod(errorCode, 10), 0x30)
errorCode := div(errorCode, 10)
let hundreds := add(mod(errorCode, 10), 0x30)
let revertReason := shl(200, add(0x42414c23000000, add(add(units, shl(8, tenths)), shl(16, hundreds))))
mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
mstore(0x24, 7)
mstore(0x44, revertReason)
revert(0, 100)
}
}
library Errors {
uint256 internal constant ADD_OVERFLOW = 0;
uint256 internal constant SUB_OVERFLOW = 1;
uint256 internal constant SUB_UNDERFLOW = 2;
uint256 internal constant MUL_OVERFLOW = 3;
uint256 internal constant ZERO_DIVISION = 4;
uint256 internal constant DIV_INTERNAL = 5;
uint256 internal constant X_OUT_OF_BOUNDS = 6;
uint256 internal constant Y_OUT_OF_BOUNDS = 7;
uint256 internal constant PRODUCT_OUT_OF_BOUNDS = 8;
uint256 internal constant INVALID_EXPONENT = 9;
uint256 internal constant OUT_OF_BOUNDS = 100;
uint256 internal constant UNSORTED_ARRAY = 101;
uint256 internal constant UNSORTED_TOKENS = 102;
uint256 internal constant INPUT_LENGTH_MISMATCH = 103;
uint256 internal constant ZERO_TOKEN = 104;
uint256 internal constant MIN_TOKENS = 200;
uint256 internal constant MAX_TOKENS = 201;
uint256 internal constant MAX_SWAP_FEE_PERCENTAGE = 202;
uint256 internal constant MIN_SWAP_FEE_PERCENTAGE = 203;
uint256 internal constant MINIMUM_BPT = 204;
uint256 internal constant CALLER_NOT_VAULT = 205;
uint256 internal constant UNINITIALIZED = 206;
uint256 internal constant BPT_IN_MAX_AMOUNT = 207;
uint256 internal constant BPT_OUT_MIN_AMOUNT = 208;
uint256 internal constant EXPIRED_PERMIT = 209;
uint256 internal constant NOT_TWO_TOKENS = 210;
uint256 internal constant MIN_AMP = 300;
uint256 internal constant MAX_AMP = 301;
uint256 internal constant MIN_WEIGHT = 302;
uint256 internal constant MAX_STABLE_TOKENS = 303;
uint256 internal constant MAX_IN_RATIO = 304;
uint256 internal constant MAX_OUT_RATIO = 305;
uint256 internal constant MIN_BPT_IN_FOR_TOKEN_OUT = 306;
uint256 internal constant MAX_OUT_BPT_FOR_TOKEN_IN = 307;
uint256 internal constant NORMALIZED_WEIGHT_INVARIANT = 308;
uint256 internal constant INVALID_TOKEN = 309;
uint256 internal constant UNHANDLED_JOIN_KIND = 310;
uint256 internal constant ZERO_INVARIANT = 311;
uint256 internal constant ORACLE_INVALID_SECONDS_QUERY = 312;
uint256 internal constant ORACLE_NOT_INITIALIZED = 313;
uint256 internal constant ORACLE_QUERY_TOO_OLD = 314;
uint256 internal constant ORACLE_INVALID_INDEX = 315;
uint256 internal constant ORACLE_BAD_SECS = 316;
uint256 internal constant AMP_END_TIME_TOO_CLOSE = 317;
uint256 internal constant AMP_ONGOING_UPDATE = 318;
uint256 internal constant AMP_RATE_TOO_HIGH = 319;
uint256 internal constant AMP_NO_ONGOING_UPDATE = 320;
uint256 internal constant STABLE_INVARIANT_DIDNT_CONVERGE = 321;
uint256 internal constant STABLE_GET_BALANCE_DIDNT_CONVERGE = 322;
uint256 internal constant RELAYER_NOT_CONTRACT = 323;
uint256 internal constant BASE_POOL_RELAYER_NOT_CALLED = 324;
uint256 internal constant REBALANCING_RELAYER_REENTERED = 325;
uint256 internal constant GRADUAL_UPDATE_TIME_TRAVEL = 326;
uint256 internal constant SWAPS_DISABLED = 327;
uint256 internal constant CALLER_IS_NOT_LBP_OWNER = 328;
uint256 internal constant PRICE_RATE_OVERFLOW = 329;
uint256 internal constant INVALID_JOIN_EXIT_KIND_WHILE_SWAPS_DISABLED = 330;
uint256 internal constant WEIGHT_CHANGE_TOO_FAST = 331;
uint256 internal constant LOWER_GREATER_THAN_UPPER_TARGET = 332;
uint256 internal constant UPPER_TARGET_TOO_HIGH = 333;
uint256 internal constant UNHANDLED_BY_LINEAR_POOL = 334;
uint256 internal constant OUT_OF_TARGET_RANGE = 335;
uint256 internal constant REENTRANCY = 400;
uint256 internal constant SENDER_NOT_ALLOWED = 401;
uint256 internal constant PAUSED = 402;
uint256 internal constant PAUSE_WINDOW_EXPIRED = 403;
uint256 internal constant MAX_PAUSE_WINDOW_DURATION = 404;
uint256 internal constant MAX_BUFFER_PERIOD_DURATION = 405;
uint256 internal constant INSUFFICIENT_BALANCE = 406;
uint256 internal constant INSUFFICIENT_ALLOWANCE = 407;
uint256 internal constant ERC20_TRANSFER_FROM_ZERO_ADDRESS = 408;
uint256 internal constant ERC20_TRANSFER_TO_ZERO_ADDRESS = 409;
uint256 internal constant ERC20_MINT_TO_ZERO_ADDRESS = 410;
uint256 internal constant ERC20_BURN_FROM_ZERO_ADDRESS = 411;
uint256 internal constant ERC20_APPROVE_FROM_ZERO_ADDRESS = 412;
uint256 internal constant ERC20_APPROVE_TO_ZERO_ADDRESS = 413;
uint256 internal constant ERC20_TRANSFER_EXCEEDS_ALLOWANCE = 414;
uint256 internal constant ERC20_DECREASED_ALLOWANCE_BELOW_ZERO = 415;
uint256 internal constant ERC20_TRANSFER_EXCEEDS_BALANCE = 416;
uint256 internal constant ERC20_BURN_EXCEEDS_ALLOWANCE = 417;
uint256 internal constant SAFE_ERC20_CALL_FAILED = 418;
uint256 internal constant ADDRESS_INSUFFICIENT_BALANCE = 419;
uint256 internal constant ADDRESS_CANNOT_SEND_VALUE = 420;
uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_INT256 = 421;
uint256 internal constant GRANT_SENDER_NOT_ADMIN = 422;
uint256 internal constant REVOKE_SENDER_NOT_ADMIN = 423;
uint256 internal constant RENOUNCE_SENDER_NOT_ALLOWED = 424;
uint256 internal constant BUFFER_PERIOD_EXPIRED = 425;
uint256 internal constant CALLER_IS_NOT_OWNER = 426;
uint256 internal constant NEW_OWNER_IS_ZERO = 427;
uint256 internal constant CODE_DEPLOYMENT_FAILED = 428;
uint256 internal constant CALL_TO_NON_CONTRACT = 429;
uint256 internal constant LOW_LEVEL_CALL_FAILED = 430;
uint256 internal constant INVALID_POOL_ID = 500;
uint256 internal constant CALLER_NOT_POOL = 501;
uint256 internal constant SENDER_NOT_ASSET_MANAGER = 502;
uint256 internal constant USER_DOESNT_ALLOW_RELAYER = 503;
uint256 internal constant INVALID_SIGNATURE = 504;
uint256 internal constant EXIT_BELOW_MIN = 505;
uint256 internal constant JOIN_ABOVE_MAX = 506;
uint256 internal constant SWAP_LIMIT = 507;
uint256 internal constant SWAP_DEADLINE = 508;
uint256 internal constant CANNOT_SWAP_SAME_TOKEN = 509;
uint256 internal constant UNKNOWN_AMOUNT_IN_FIRST_SWAP = 510;
uint256 internal constant MALCONSTRUCTED_MULTIHOP_SWAP = 511;
uint256 internal constant INTERNAL_BALANCE_OVERFLOW = 512;
uint256 internal constant INSUFFICIENT_INTERNAL_BALANCE = 513;
uint256 internal constant INVALID_ETH_INTERNAL_BALANCE = 514;
uint256 internal constant INVALID_POST_LOAN_BALANCE = 515;
uint256 internal constant INSUFFICIENT_ETH = 516;
uint256 internal constant UNALLOCATED_ETH = 517;
uint256 internal constant ETH_TRANSFER = 518;
uint256 internal constant CANNOT_USE_ETH_SENTINEL = 519;
uint256 internal constant TOKENS_MISMATCH = 520;
uint256 internal constant TOKEN_NOT_REGISTERED = 521;
uint256 internal constant TOKEN_ALREADY_REGISTERED = 522;
uint256 internal constant TOKENS_ALREADY_SET = 523;
uint256 internal constant TOKENS_LENGTH_MUST_BE_2 = 524;
uint256 internal constant NONZERO_TOKEN_BALANCE = 525;
uint256 internal constant BALANCE_TOTAL_OVERFLOW = 526;
uint256 internal constant POOL_NO_TOKENS = 527;
uint256 internal constant INSUFFICIENT_FLASH_LOAN_BALANCE = 528;
uint256 internal constant SWAP_FEE_PERCENTAGE_TOO_HIGH = 600;
uint256 internal constant FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH = 601;
uint256 internal constant INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT = 602;
}
文件 2 的 32：BalancerPoolToken.sol
pragma solidity ^0.7.0;
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ERC20.sol";
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ERC20Permit.sol";
contract BalancerPoolToken is ERC20, ERC20Permit {
constructor(string memory tokenName, string memory tokenSymbol)
ERC20(tokenName, tokenSymbol)
ERC20Permit(tokenName)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
uint256 currentAllowance = allowance(sender, msg.sender);
_require(msg.sender == sender || currentAllowance >= amount, Errors.ERC20_TRANSFER_EXCEEDS_ALLOWANCE);
_transfer(sender, recipient, amount);
if (msg.sender != sender && currentAllowance != uint256(-1)) {
_approve(sender, msg.sender, currentAllowance - amount);
}
return true;
}
function decreaseAllowance(address spender, uint256 amount) public override returns (bool) {
uint256 currentAllowance = allowance(msg.sender, spender);
if (amount >= currentAllowance) {
_approve(msg.sender, spender, 0);
} else {
_approve(msg.sender, spender, currentAllowance - amount);
}
return true;
}
function _mintPoolTokens(address recipient, uint256 amount) internal {
_mint(recipient, amount);
}
function _burnPoolTokens(address sender, uint256 amount) internal {
_burn(sender, amount);
}
}
文件 3 的 32：Buffer.sol
pragma solidity ^0.7.0;
library Buffer {
uint256 internal constant SIZE = 20;
function prev(uint256 index) internal pure returns (uint256) {
return sub(index, 1);
}
function next(uint256 index) internal pure returns (uint256) {
return add(index, 1);
}
function add(uint256 index, uint256 offset) internal pure returns (uint256) {
return (index + offset) % SIZE;
}
function sub(uint256 index, uint256 offset) internal pure returns (uint256) {
return (index + SIZE - offset) % SIZE;
}
}
文件 4 的 32：EIP712.sol
pragma solidity ^0.7.0;
abstract contract EIP712 {
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
_HASHED_NAME = keccak256(bytes(name));
_HASHED_VERSION = keccak256(bytes(version));
_TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
}
function _domainSeparatorV4() internal view virtual returns (bytes32) {
return keccak256(abi.encode(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION, _getChainId(), address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", _domainSeparatorV4(), structHash));
}
function _getChainId() private view returns (uint256 chainId) {
this;
assembly {
chainId := chainid()
}
}
}
文件 5 的 32：ERC20.sol
pragma solidity ^0.7.0;
import "../helpers/BalancerErrors.sol";
import "./IERC20.sol";
import "./SafeMath.sol";
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(
sender,
msg.sender,
_allowances[sender][msg.sender].sub(amount, Errors.ERC20_TRANSFER_EXCEEDS_ALLOWANCE)
);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(
msg.sender,
spender,
_allowances[msg.sender][spender].sub(subtractedValue, Errors.ERC20_DECREASED_ALLOWANCE_BELOW_ZERO)
);
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
_require(sender != address(0), Errors.ERC20_TRANSFER_FROM_ZERO_ADDRESS);
_require(recipient != address(0), Errors.ERC20_TRANSFER_TO_ZERO_ADDRESS);
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, Errors.ERC20_TRANSFER_EXCEEDS_BALANCE);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
_require(account != address(0), Errors.ERC20_BURN_FROM_ZERO_ADDRESS);
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, Errors.ERC20_BURN_EXCEEDS_ALLOWANCE);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
文件 6 的 32：ERC20Permit.sol
pragma solidity ^0.7.0;
import "./ERC20.sol";
import "./IERC20Permit.sol";
import "./EIP712.sol";
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
mapping(address => uint256) private _nonces;
bytes32 private immutable _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
_require(block.timestamp <= deadline, Errors.EXPIRED_PERMIT);
uint256 nonce = _nonces[owner];
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, nonce, deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ecrecover(hash, v, r, s);
_require((signer != address(0)) && (signer == owner), Errors.INVALID_SIGNATURE);
_nonces[owner] = nonce + 1;
_approve(owner, spender, value);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner];
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
}
文件 7 的 32：Errors.sol
pragma solidity >=0.7.0;
function _require(bool condition, uint256 errorCode) pure {
if (!condition) _revert(errorCode);
}
function _revert(uint256 errorCode) pure {
assembly {
let units := add(mod(errorCode, 10), 0x30)
errorCode := div(errorCode, 10)
let tenths := add(mod(errorCode, 10), 0x30)
errorCode := div(errorCode, 10)
let hundreds := add(mod(errorCode, 10), 0x30)
let revertReason := shl(200, add(0x3f534e5323000000, add(add(units, shl(8, tenths)), shl(16, hundreds))))
mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
mstore(0x24, 7)
mstore(0x44, revertReason)
revert(0, 100)
}
}
library Errors {
uint256 internal constant CALLER_NOT_VAULT = 100;
uint256 internal constant INVALID_G1 = 101;
uint256 internal constant INVALID_G2 = 102;
uint256 internal constant INVALID_POOL_ID = 103;
uint256 internal constant POOL_ALREADY_EXISTS = 104;
uint256 internal constant POOL_PAST_MATURITY = 105;
uint256 internal constant SWAP_TOO_SMALL = 106;
uint256 internal constant NEGATIVE_RATE = 107;
uint256 internal constant BPT_OUT_MIN_AMOUNT = 108;
uint256 internal constant INVALID_SERIES = 109;
}
文件 8 的 32：FixedPoint.sol
pragma solidity ^0.7.0;
import "./LogExpMath.sol";
import "../helpers/BalancerErrors.sol";
library FixedPoint {
uint256 internal constant ONE = 1e18;
uint256 internal constant MAX_POW_RELATIVE_ERROR = 10000;
uint256 internal constant MIN_POW_BASE_FREE_EXPONENT = 0.7e18;
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
_require(c >= a, Errors.ADD_OVERFLOW);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
_require(b <= a, Errors.SUB_OVERFLOW);
uint256 c = a - b;
return c;
}
function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 product = a * b;
_require(a == 0 || product / a == b, Errors.MUL_OVERFLOW);
return product / ONE;
}
function mulUp(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 product = a * b;
_require(a == 0 || product / a == b, Errors.MUL_OVERFLOW);
if (product == 0) {
return 0;
} else {
return ((product - 1) / ONE) + 1;
}
}
function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
_require(b != 0, Errors.ZERO_DIVISION);
if (a == 0) {
return 0;
} else {
uint256 aInflated = a * ONE;
_require(aInflated / a == ONE, Errors.DIV_INTERNAL);
return aInflated / b;
}
}
function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
_require(b != 0, Errors.ZERO_DIVISION);
if (a == 0) {
return 0;
} else {
uint256 aInflated = a * ONE;
_require(aInflated / a == ONE, Errors.DIV_INTERNAL);
return ((aInflated - 1) / b) + 1;
}
}
function powDown(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 raw = LogExpMath.pow(x, y);
uint256 maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), 1);
if (raw < maxError) {
return 0;
} else {
return sub(raw, maxError);
}
}
function powUp(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 raw = LogExpMath.pow(x, y);
uint256 maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), 1);
return add(raw, maxError);
}
function complement(uint256 x) internal pure returns (uint256) {
return (x < ONE) ? (ONE - x) : 0;
}
}
文件 9 的 32：IAsset.sol
pragma solidity ^0.7.0;
interface IAsset {
}
文件 10 的 32：IAuthorizer.sol
pragma solidity ^0.7.0;
interface IAuthorizer {
function canPerform(
bytes32 actionId,
address account,
address where
) external view returns (bool);
}
文件 11 的 32：IBasePool.sol
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "./IVault.sol";
import "./IPoolSwapStructs.sol";
interface IBasePool is IPoolSwapStructs {
function onJoinPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts);
function onExitPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts);
function getPoolId() external view returns (bytes32);
}
文件 12 的 32：IERC20.sol
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
文件 13 的 32：IERC20Permit.sol
pragma solidity ^0.7.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 14 的 32：IFlashLoanRecipient.sol
pragma solidity ^0.7.0;
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol";
interface IFlashLoanRecipient {
function receiveFlashLoan(
IERC20[] memory tokens,
uint256[] memory amounts,
uint256[] memory feeAmounts,
bytes memory userData
) external;
}
文件 15 的 32：IMinimalSwapInfoPool.sol
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "./IBasePool.sol";
interface IMinimalSwapInfoPool is IBasePool {
function onSwap(
SwapRequest memory swapRequest,
uint256 currentBalanceTokenIn,
uint256 currentBalanceTokenOut
) external returns (uint256 amount);
}
文件 16 的 32：IPoolPriceOracle.sol
pragma solidity ^0.7.0;
interface IPoolPriceOracle {
function getSample(uint256 index)
external
view
returns (
int256 logPairPrice,
int256 accLogPairPrice,
int256 logBptPrice,
int256 accLogBptPrice,
int256 logInvariant,
int256 accLogInvariant,
uint256 timestamp
);
function getTotalSamples() external view returns (uint256);
}
文件 17 的 32：IPoolSwapStructs.sol
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol";
import "./IVault.sol";
interface IPoolSwapStructs {
struct SwapRequest {
IVault.SwapKind kind;
IERC20 tokenIn;
IERC20 tokenOut;
uint256 amount;
bytes32 poolId;
uint256 lastChangeBlock;
address from;
address to;
bytes userData;
}
}
文件 18 的 32：IPriceOracle.sol
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
interface IPriceOracle {
enum Variable { PAIR_PRICE, BPT_PRICE, INVARIANT }
function getTimeWeightedAverage(OracleAverageQuery[] memory queries)
external
view
returns (uint256[] memory results);
function getLatest(Variable variable) external view returns (uint256);
struct OracleAverageQuery {
Variable variable;
uint256 secs;
uint256 ago;
}
function getLargestSafeQueryWindow() external view returns (uint256);
function getPastAccumulators(OracleAccumulatorQuery[] memory queries)
external
view
returns (int256[] memory results);
struct OracleAccumulatorQuery {
Variable variable;
uint256 ago;
}
}
文件 19 的 32：IProtocolFeesCollector.sol
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol";
import "./IVault.sol";
import "./IAuthorizer.sol";
interface IProtocolFeesCollector {
event SwapFeePercentageChanged(uint256 newSwapFeePercentage);
event FlashLoanFeePercentageChanged(uint256 newFlashLoanFeePercentage);
function withdrawCollectedFees(
IERC20[] calldata tokens,
uint256[] calldata amounts,
address recipient
) external;
function setSwapFeePercentage(uint256 newSwapFeePercentage) external;
function setFlashLoanFeePercentage(uint256 newFlashLoanFeePercentage) external;
function getSwapFeePercentage() external view returns (uint256);
function getFlashLoanFeePercentage() external view returns (uint256);
function getCollectedFeeAmounts(IERC20[] memory tokens) external view returns (uint256[] memory feeAmounts);
function getAuthorizer() external view returns (IAuthorizer);
function vault() external view returns (IVault);
}
文件 20 的 32：ISignaturesValidator.sol
pragma solidity ^0.7.0;
interface ISignaturesValidator {
function getDomainSeparator() external view returns (bytes32);
function getNextNonce(address user) external view returns (uint256);
}
文件 21 的 32：ITemporarilyPausable.sol
pragma solidity ^0.7.0;
interface ITemporarilyPausable {
event PausedStateChanged(bool paused);
function getPausedState()
external
view
returns (
bool paused,
uint256 pauseWindowEndTime,
uint256 bufferPeriodEndTime
);
}
文件 22 的 32：IVault.sol
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/ISignaturesValidator.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/ITemporarilyPausable.sol";
import "@balancer-labs/v2-solidity-utils/contracts/misc/IWETH.sol";
import "./IAsset.sol";
import "./IAuthorizer.sol";
import "./IFlashLoanRecipient.sol";
import "./IProtocolFeesCollector.sol";
pragma solidity ^0.7.0;
interface IVault is ISignaturesValidator, ITemporarilyPausable {
function getAuthorizer() external view returns (IAuthorizer);
function setAuthorizer(IAuthorizer newAuthorizer) external;
event AuthorizerChanged(IAuthorizer indexed newAuthorizer);
function hasApprovedRelayer(address user, address relayer) external view returns (bool);
function setRelayerApproval(
address sender,
address relayer,
bool approved
) external;
event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);
function getInternalBalance(address user, IERC20[] memory tokens) external view returns (uint256[] memory);
function manageUserBalance(UserBalanceOp[] memory ops) external payable;
struct UserBalanceOp {
UserBalanceOpKind kind;
IAsset asset;
uint256 amount;
address sender;
address payable recipient;
}
enum UserBalanceOpKind { DEPOSIT_INTERNAL, WITHDRAW_INTERNAL, TRANSFER_INTERNAL, TRANSFER_EXTERNAL }
event InternalBalanceChanged(address indexed user, IERC20 indexed token, int256 delta);
event ExternalBalanceTransfer(IERC20 indexed token, address indexed sender, address recipient, uint256 amount);
enum PoolSpecialization { GENERAL, MINIMAL_SWAP_INFO, TWO_TOKEN }
function registerPool(PoolSpecialization specialization) external returns (bytes32);
event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, PoolSpecialization specialization);
function getPool(bytes32 poolId) external view returns (address, PoolSpecialization);
function registerTokens(
bytes32 poolId,
IERC20[] memory tokens,
address[] memory assetManagers
) external;
event TokensRegistered(bytes32 indexed poolId, IERC20[] tokens, address[] assetManagers);
function deregisterTokens(bytes32 poolId, IERC20[] memory tokens) external;
event TokensDeregistered(bytes32 indexed poolId, IERC20[] tokens);
function getPoolTokenInfo(bytes32 poolId, IERC20 token)
external
view
returns (
uint256 cash,
uint256 managed,
uint256 lastChangeBlock,
address assetManager
);
function getPoolTokens(bytes32 poolId)
external
view
returns (
IERC20[] memory tokens,
uint256[] memory balances,
uint256 lastChangeBlock
);
function joinPool(
bytes32 poolId,
address sender,
address recipient,
JoinPoolRequest memory request
) external payable;
struct JoinPoolRequest {
IAsset[] assets;
uint256[] maxAmountsIn;
bytes userData;
bool fromInternalBalance;
}
function exitPool(
bytes32 poolId,
address sender,
address payable recipient,
ExitPoolRequest memory request
) external;
struct ExitPoolRequest {
IAsset[] assets;
uint256[] minAmountsOut;
bytes userData;
bool toInternalBalance;
}
event PoolBalanceChanged(
bytes32 indexed poolId,
address indexed liquidityProvider,
IERC20[] tokens,
int256[] deltas,
uint256[] protocolFeeAmounts
);
enum PoolBalanceChangeKind { JOIN, EXIT }
enum SwapKind { GIVEN_IN, GIVEN_OUT }
function swap(
SingleSwap memory singleSwap,
FundManagement memory funds,
uint256 limit,
uint256 deadline
) external payable returns (uint256);
struct SingleSwap {
bytes32 poolId;
SwapKind kind;
IAsset assetIn;
IAsset assetOut;
uint256 amount;
bytes userData;
}
function batchSwap(
SwapKind kind,
BatchSwapStep[] memory swaps,
IAsset[] memory assets,
FundManagement memory funds,
int256[] memory limits,
uint256 deadline
) external payable returns (int256[] memory);
struct BatchSwapStep {
bytes32 poolId;
uint256 assetInIndex;
uint256 assetOutIndex;
uint256 amount;
bytes userData;
}
event Swap(
bytes32 indexed poolId,
IERC20 indexed tokenIn,
IERC20 indexed tokenOut,
uint256 amountIn,
uint256 amountOut
);
struct FundManagement {
address sender;
bool fromInternalBalance;
address payable recipient;
bool toInternalBalance;
}
function queryBatchSwap(
SwapKind kind,
BatchSwapStep[] memory swaps,
IAsset[] memory assets,
FundManagement memory funds
) external returns (int256[] memory assetDeltas);
function flashLoan(
IFlashLoanRecipient recipient,
IERC20[] memory tokens,
uint256[] memory amounts,
bytes memory userData
) external;
event FlashLoan(IFlashLoanRecipient indexed recipient, IERC20 indexed token, uint256 amount, uint256 feeAmount);
function managePoolBalance(PoolBalanceOp[] memory ops) external;
struct PoolBalanceOp {
PoolBalanceOpKind kind;
bytes32 poolId;
IERC20 token;
uint256 amount;
}
enum PoolBalanceOpKind { WITHDRAW, DEPOSIT, UPDATE }
event PoolBalanceManaged(
bytes32 indexed poolId,
address indexed assetManager,
IERC20 indexed token,
int256 cashDelta,
int256 managedDelta
);
function getProtocolFeesCollector() external view returns (IProtocolFeesCollector);
function setPaused(bool paused) external;
function WETH() external view returns (IWETH);
}
文件 23 的 32：IWETH.sol
pragma solidity ^0.7.0;
import "../openzeppelin/IERC20.sol";
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 amount) external;
}
文件 24 的 32：LogCompression.sol
pragma solidity ^0.7.0;
import "../math/LogExpMath.sol";
library LogCompression {
int256 private constant _LOG_COMPRESSION_FACTOR = 1e14;
int256 private constant _HALF_LOG_COMPRESSION_FACTOR = 0.5e14;
function toLowResLog(uint256 value) internal pure returns (int256) {
int256 ln = LogExpMath.ln(int256(value));
int256 lnWithError = (ln > 0 ? ln + _HALF_LOG_COMPRESSION_FACTOR : ln - _HALF_LOG_COMPRESSION_FACTOR);
return lnWithError / _LOG_COMPRESSION_FACTOR;
}
function fromLowResLog(int256 value) internal pure returns (uint256) {
return uint256(LogExpMath.exp(value * _LOG_COMPRESSION_FACTOR));
}
}
文件 25 的 32：LogExpMath.sol
pragma solidity ^0.7.0;
import "../helpers/BalancerErrors.sol";
library LogExpMath {
int256 constant ONE_18 = 1e18;
int256 constant ONE_20 = 1e20;
int256 constant ONE_36 = 1e36;
int256 constant MAX_NATURAL_EXPONENT = 130e18;
int256 constant MIN_NATURAL_EXPONENT = -41e18;
int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17;
int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17;
uint256 constant MILD_EXPONENT_BOUND = 2**254 / uint256(ONE_20);
int256 constant x0 = 128000000000000000000;
int256 constant a0 = 38877084059945950922200000000000000000000000000000000000;
int256 constant x1 = 64000000000000000000;
int256 constant a1 = 6235149080811616882910000000;
int256 constant x2 = 3200000000000000000000;
int256 constant a2 = 7896296018268069516100000000000000;
int256 constant x3 = 1600000000000000000000;
int256 constant a3 = 888611052050787263676000000;
int256 constant x4 = 800000000000000000000;
int256 constant a4 = 298095798704172827474000;
int256 constant x5 = 400000000000000000000;
int256 constant a5 = 5459815003314423907810;
int256 constant x6 = 200000000000000000000;
int256 constant a6 = 738905609893065022723;
int256 constant x7 = 100000000000000000000;
int256 constant a7 = 271828182845904523536;
int256 constant x8 = 50000000000000000000;
int256 constant a8 = 164872127070012814685;
int256 constant x9 = 25000000000000000000;
int256 constant a9 = 128402541668774148407;
int256 constant x10 = 12500000000000000000;
int256 constant a10 = 113314845306682631683;
int256 constant x11 = 6250000000000000000;
int256 constant a11 = 106449445891785942956;
function pow(uint256 x, uint256 y) internal pure returns (uint256) {
if (y == 0) {
return uint256(ONE_18);
}
if (x == 0) {
return 0;
}
_require(x < 2**255, Errors.X_OUT_OF_BOUNDS);
int256 x_int256 = int256(x);
_require(y < MILD_EXPONENT_BOUND, Errors.Y_OUT_OF_BOUNDS);
int256 y_int256 = int256(y);
int256 logx_times_y;
if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
int256 ln_36_x = _ln_36(x_int256);
logx_times_y = ((ln_36_x / ONE_18) * y_int256 + ((ln_36_x % ONE_18) * y_int256) / ONE_18);
} else {
logx_times_y = _ln(x_int256) * y_int256;
}
logx_times_y /= ONE_18;
_require(
MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
Errors.PRODUCT_OUT_OF_BOUNDS
);
return uint256(exp(logx_times_y));
}
function exp(int256 x) internal pure returns (int256) {
_require(x >= MIN_NATURAL_EXPONENT && x <= MAX_NATURAL_EXPONENT, Errors.INVALID_EXPONENT);
if (x < 0) {
return ((ONE_18 * ONE_18) / exp(-x));
}
int256 firstAN;
if (x >= x0) {
x -= x0;
firstAN = a0;
} else if (x >= x1) {
x -= x1;
firstAN = a1;
} else {
firstAN = 1;
}
x *= 100;
int256 product = ONE_20;
if (x >= x2) {
x -= x2;
product = (product * a2) / ONE_20;
}
if (x >= x3) {
x -= x3;
product = (product * a3) / ONE_20;
}
if (x >= x4) {
x -= x4;
product = (product * a4) / ONE_20;
}
if (x >= x5) {
x -= x5;
product = (product * a5) / ONE_20;
}
if (x >= x6) {
x -= x6;
product = (product * a6) / ONE_20;
}
if (x >= x7) {
x -= x7;
product = (product * a7) / ONE_20;
}
if (x >= x8) {
x -= x8;
product = (product * a8) / ONE_20;
}
if (x >= x9) {
x -= x9;
product = (product * a9) / ONE_20;
}
int256 seriesSum = ONE_20;
int256 term;
term = x;
seriesSum += term;
term = ((term * x) / ONE_20) / 2;
seriesSum += term;
term = ((term * x) / ONE_20) / 3;
seriesSum += term;
term = ((term * x) / ONE_20) / 4;
seriesSum += term;
term = ((term * x) / ONE_20) / 5;
seriesSum += term;
term = ((term * x) / ONE_20) / 6;
seriesSum += term;
term = ((term * x) / ONE_20) / 7;
seriesSum += term;
term = ((term * x) / ONE_20) / 8;
seriesSum += term;
term = ((term * x) / ONE_20) / 9;
seriesSum += term;
term = ((term * x) / ONE_20) / 10;
seriesSum += term;
term = ((term * x) / ONE_20) / 11;
seriesSum += term;
term = ((term * x) / ONE_20) / 12;
seriesSum += term;
return (((product * seriesSum) / ONE_20) * firstAN) / 100;
}
function log(int256 arg, int256 base) internal pure returns (int256) {
int256 logBase;
if (LN_36_LOWER_BOUND < base && base < LN_36_UPPER_BOUND) {
logBase = _ln_36(base);
} else {
logBase = _ln(base) * ONE_18;
}
int256 logArg;
if (LN_36_LOWER_BOUND < arg && arg < LN_36_UPPER_BOUND) {
logArg = _ln_36(arg);
} else {
logArg = _ln(arg) * ONE_18;
}
return (logArg * ONE_18) / logBase;
}
function ln(int256 a) internal pure returns (int256) {
_require(a > 0, Errors.OUT_OF_BOUNDS);
if (LN_36_LOWER_BOUND < a && a < LN_36_UPPER_BOUND) {
return _ln_36(a) / ONE_18;
} else {
return _ln(a);
}
}
function _ln(int256 a) private pure returns (int256) {
if (a < ONE_18) {
return (-_ln((ONE_18 * ONE_18) / a));
}
int256 sum = 0;
if (a >= a0 * ONE_18) {
a /= a0;
sum += x0;
}
if (a >= a1 * ONE_18) {
a /= a1;
sum += x1;
}
sum *= 100;
a *= 100;
if (a >= a2) {
a = (a * ONE_20) / a2;
sum += x2;
}
if (a >= a3) {
a = (a * ONE_20) / a3;
sum += x3;
}
if (a >= a4) {
a = (a * ONE_20) / a4;
sum += x4;
}
if (a >= a5) {
a = (a * ONE_20) / a5;
sum += x5;
}
if (a >= a6) {
a = (a * ONE_20) / a6;
sum += x6;
}
if (a >= a7) {
a = (a * ONE_20) / a7;
sum += x7;
}
if (a >= a8) {
a = (a * ONE_20) / a8;
sum += x8;
}
if (a >= a9) {
a = (a * ONE_20) / a9;
sum += x9;
}
if (a >= a10) {
a = (a * ONE_20) / a10;
sum += x10;
}
if (a >= a11) {
a = (a * ONE_20) / a11;
sum += x11;
}
int256 z = ((a - ONE_20) * ONE_20) / (a + ONE_20);
int256 z_squared = (z * z) / ONE_20;
int256 num = z;
int256 seriesSum = num;
num = (num * z_squared) / ONE_20;
seriesSum += num / 3;
num = (num * z_squared) / ONE_20;
seriesSum += num / 5;
num = (num * z_squared) / ONE_20;
seriesSum += num / 7;
num = (num * z_squared) / ONE_20;
seriesSum += num / 9;
num = (num * z_squared) / ONE_20;
seriesSum += num / 11;
seriesSum *= 2;
return (sum + seriesSum) / 100;
}
function _ln_36(int256 x) private pure returns (int256) {
x *= ONE_18;
int256 z = ((x - ONE_36) * ONE_36) / (x + ONE_36);
int256 z_squared = (z * z) / ONE_36;
int256 num = z;
int256 seriesSum = num;
num = (num * z_squared) / ONE_36;
seriesSum += num / 3;
num = (num * z_squared) / ONE_36;
seriesSum += num / 5;
num = (num * z_squared) / ONE_36;
seriesSum += num / 7;
num = (num * z_squared) / ONE_36;
seriesSum += num / 9;
num = (num * z_squared) / ONE_36;
seriesSum += num / 11;
num = (num * z_squared) / ONE_36;
seriesSum += num / 13;
num = (num * z_squared) / ONE_36;
seriesSum += num / 15;
return seriesSum * 2;
}
}
文件 26 的 32：Math.sol
pragma solidity ^0.7.0;
import "../helpers/BalancerErrors.sol";
library Math {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
_require(c >= a, Errors.ADD_OVERFLOW);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
_require((b >= 0 && c >= a) || (b < 0 && c < a), Errors.ADD_OVERFLOW);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
_require(b <= a, Errors.SUB_OVERFLOW);
uint256 c = a - b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
_require((b >= 0 && c <= a) || (b < 0 && c > a), Errors.SUB_OVERFLOW);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
_require(a == 0 || c / a == b, Errors.MUL_OVERFLOW);
return c;
}
function div(
uint256 a,
uint256 b,
bool roundUp
) internal pure returns (uint256) {
return roundUp ? divUp(a, b) : divDown(a, b);
}
function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
_require(b != 0, Errors.ZERO_DIVISION);
return a / b;
}
function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
_require(b != 0, Errors.ZERO_DIVISION);
if (a == 0) {
return 0;
} else {
return 1 + (a - 1) / b;
}
}
}
文件 27 的 32：PoolPriceOracle.sol
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol";
import "./interfaces/IPriceOracle.sol";
import "./interfaces/IPoolPriceOracle.sol";
import "./Buffer.sol";
import "./Samples.sol";
import "./QueryProcessor.sol";
abstract contract PoolPriceOracle is IPoolPriceOracle, IPriceOracle {
using Buffer for uint256;
using Samples for bytes32;
uint256 private constant _MAX_SAMPLE_DURATION = 20 minutes;
mapping(uint256 => bytes32) internal _samples;
function getSample(uint256 index)
external
view
override
returns (
int256 logPairPrice,
int256 accLogPairPrice,
int256 logBptPrice,
int256 accLogBptPrice,
int256 logInvariant,
int256 accLogInvariant,
uint256 timestamp
)
{
_require(index < Buffer.SIZE, Errors.ORACLE_INVALID_INDEX);
bytes32 sample = _getSample(index);
return sample.unpack();
}
function getTotalSamples() external pure override returns (uint256) {
return Buffer.SIZE;
}
function dirtyUninitializedOracleSamples(uint256 startIndex, uint256 endIndex) external {
_require(startIndex < endIndex && endIndex <= Buffer.SIZE, Errors.OUT_OF_BOUNDS);
bytes32 initSample = Samples.pack(1, 0, 0, 0, 0, 0, 0);
for (uint256 i = startIndex; i < endIndex; i++) {
if (_samples[i].timestamp() == 0) {
_samples[i] = initSample;
}
}
}
function getLargestSafeQueryWindow() external pure override returns (uint256) {
return 6.66 hours;
}
function getLatest(Variable variable) external view override returns (uint256) {
return QueryProcessor.getInstantValue(_samples, variable, _getOracleIndex());
}
function getTimeWeightedAverage(OracleAverageQuery[] memory queries)
external
view
override
returns (uint256[] memory results)
{
results = new uint256[](queries.length);
uint256 latestIndex = _getOracleIndex();
for (uint256 i = 0; i < queries.length; ++i) {
results[i] = QueryProcessor.getTimeWeightedAverage(_samples, queries[i], latestIndex);
}
}
function getPastAccumulators(OracleAccumulatorQuery[] memory queries)
external
view
override
returns (int256[] memory results)
{
results = new int256[](queries.length);
uint256 latestIndex = _getOracleIndex();
OracleAccumulatorQuery memory query;
for (uint256 i = 0; i < queries.length; ++i) {
query = queries[i];
results[i] = _getPastAccumulator(query.variable, latestIndex, query.ago);
}
}
function _processPriceData(
uint256 latestSampleCreationTimestamp,
uint256 latestIndex,
int256 logPairPrice,
int256 logBptPrice,
int256 logInvariant
) internal returns (uint256) {
bytes32 sample = _getSample(latestIndex).update(logPairPrice, logBptPrice, logInvariant, block.timestamp);
bool newSample = block.timestamp - latestSampleCreationTimestamp >= _MAX_SAMPLE_DURATION;
latestIndex = newSample ? latestIndex.next() : latestIndex;
_samples[latestIndex] = sample;
return latestIndex;
}
function _getPastAccumulator(
IPriceOracle.Variable variable,
uint256 latestIndex,
uint256 ago
) internal view returns (int256) {
return QueryProcessor.getPastAccumulator(_samples, variable, latestIndex, ago);
}
function _findNearestSample(
uint256 lookUpDate,
uint256 offset,
uint256 length
) internal view returns (bytes32 prev, bytes32 next) {
return QueryProcessor.findNearestSample(_samples, lookUpDate, offset, length);
}
function _getSample(uint256 index) internal view returns (bytes32) {
return _samples[index];
}
function _getOracleIndex() internal view virtual returns (uint256);
}
文件 28 的 32：QueryProcessor.sol
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol";
import "@balancer-labs/v2-solidity-utils/contracts/helpers/LogCompression.sol";
import "./interfaces/IPriceOracle.sol";
import "./Buffer.sol";
import "./Samples.sol";
library QueryProcessor {
using Buffer for uint256;
using Samples for bytes32;
using LogCompression for int256;
function getInstantValue(
mapping(uint256 => bytes32) storage samples,
IPriceOracle.Variable variable,
uint256 index
) external view returns (uint256) {
bytes32 sample = samples[index];
_require(sample.timestamp() > 0, Errors.ORACLE_NOT_INITIALIZED);
int256 rawInstantValue = sample.instant(variable);
return LogCompression.fromLowResLog(rawInstantValue);
}
function getTimeWeightedAverage(
mapping(uint256 => bytes32) storage samples,
IPriceOracle.OracleAverageQuery memory query,
uint256 latestIndex
) external view returns (uint256) {
_require(query.secs != 0, Errors.ORACLE_BAD_SECS);
int256 beginAccumulator = getPastAccumulator(samples, query.variable, latestIndex, query.ago + query.secs);
int256 endAccumulator = getPastAccumulator(samples, query.variable, latestIndex, query.ago);
return LogCompression.fromLowResLog((endAccumulator - beginAccumulator) / int256(query.secs));
}
function getPastAccumulator(
mapping(uint256 => bytes32) storage samples,
IPriceOracle.Variable variable,
uint256 latestIndex,
uint256 ago
) public view returns (int256) {
_require(block.timestamp >= ago, Errors.ORACLE_INVALID_SECONDS_QUERY);
uint256 lookUpTime = block.timestamp - ago;
bytes32 latestSample = samples[latestIndex];
uint256 latestTimestamp = latestSample.timestamp();
_require(latestTimestamp > 0, Errors.ORACLE_NOT_INITIALIZED);
if (latestTimestamp <= lookUpTime) {
uint256 elapsed = lookUpTime - latestTimestamp;
return latestSample.accumulator(variable) + (latestSample.instant(variable) * int256(elapsed));
} else {
uint256 bufferLength;
uint256 oldestIndex = latestIndex.next();
{
bytes32 oldestSample = samples[oldestIndex];
uint256 oldestTimestamp = oldestSample.timestamp();
if (oldestTimestamp > 0) {
bufferLength = Buffer.SIZE;
} else {
bufferLength = oldestIndex;
oldestIndex = 0;
oldestTimestamp = samples[0].timestamp();
}
_require(oldestTimestamp <= lookUpTime, Errors.ORACLE_QUERY_TOO_OLD);
}
(bytes32 prev, bytes32 next) = findNearestSample(samples, lookUpTime, oldestIndex, bufferLength);
uint256 samplesTimeDiff = next.timestamp() - prev.timestamp();
if (samplesTimeDiff > 0) {
int256 samplesAccDiff = next.accumulator(variable) - prev.accumulator(variable);
uint256 elapsed = lookUpTime - prev.timestamp();
return prev.accumulator(variable) + ((samplesAccDiff * int256(elapsed)) / int256(samplesTimeDiff));
} else {
return prev.accumulator(variable);
}
}
}
function findNearestSample(
mapping(uint256 => bytes32) storage samples,
uint256 lookUpDate,
uint256 offset,
uint256 length
) public view returns (bytes32 prev, bytes32 next) {
uint256 low = 0;
uint256 high = length - 1;
uint256 mid;
bytes32 sample;
uint256 sampleTimestamp;
while (low <= high) {
uint256 midWithoutOffset = (high + low) / 2;
mid = midWithoutOffset.add(offset);
sample = samples[mid];
sampleTimestamp = sample.timestamp();
if (sampleTimestamp < lookUpDate) {
low = midWithoutOffset + 1;
} else if (sampleTimestamp > lookUpDate) {
high = midWithoutOffset - 1;
} else {
return (sample, sample);
}
}
return sampleTimestamp < lookUpDate ? (sample, samples[mid.next()]) : (samples[mid.prev()], sample);
}
}
文件 29 的 32：SafeMath.sol
pragma solidity ^0.7.0;
import "../helpers/BalancerErrors.sol";
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
_require(c >= a, Errors.ADD_OVERFLOW);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, Errors.SUB_OVERFLOW);
}
function sub(uint256 a, uint256 b, uint256 errorCode) internal pure returns (uint256) {
_require(b <= a, errorCode);
uint256 c = a - b;
return c;
}
}
文件 30 的 32：Samples.sol
pragma solidity ^0.7.0;
import "@balancer-labs/v2-solidity-utils/contracts/helpers/WordCodec.sol";
import "./interfaces/IPriceOracle.sol";
library Samples {
using WordCodec for int256;
using WordCodec for uint256;
using WordCodec for bytes32;
uint256 internal constant _TIMESTAMP_OFFSET = 0;
uint256 internal constant _ACC_LOG_INVARIANT_OFFSET = 31;
uint256 internal constant _INST_LOG_INVARIANT_OFFSET = 84;
uint256 internal constant _ACC_LOG_BPT_PRICE_OFFSET = 106;
uint256 internal constant _INST_LOG_BPT_PRICE_OFFSET = 159;
uint256 internal constant _ACC_LOG_PAIR_PRICE_OFFSET = 181;
uint256 internal constant _INST_LOG_PAIR_PRICE_OFFSET = 234;
function update(
bytes32 sample,
int256 instLogPairPrice,
int256 instLogBptPrice,
int256 instLogInvariant,
uint256 currentTimestamp
) internal pure returns (bytes32) {
int256 elapsed = int256(currentTimestamp - timestamp(sample));
int256 accLogPairPrice = _accLogPairPrice(sample) + instLogPairPrice * elapsed;
int256 accLogBptPrice = _accLogBptPrice(sample) + instLogBptPrice * elapsed;
int256 accLogInvariant = _accLogInvariant(sample) + instLogInvariant * elapsed;
return
pack(
instLogPairPrice,
accLogPairPrice,
instLogBptPrice,
accLogBptPrice,
instLogInvariant,
accLogInvariant,
currentTimestamp
);
}
function instant(bytes32 sample, IPriceOracle.Variable variable) internal pure returns (int256) {
if (variable == IPriceOracle.Variable.PAIR_PRICE) {
return _instLogPairPrice(sample);
} else if (variable == IPriceOracle.Variable.BPT_PRICE) {
return _instLogBptPrice(sample);
} else {
return _instLogInvariant(sample);
}
}
function accumulator(bytes32 sample, IPriceOracle.Variable variable) internal pure returns (int256) {
if (variable == IPriceOracle.Variable.PAIR_PRICE) {
return _accLogPairPrice(sample);
} else if (variable == IPriceOracle.Variable.BPT_PRICE) {
return _accLogBptPrice(sample);
} else {
return _accLogInvariant(sample);
}
}
function timestamp(bytes32 sample) internal pure returns (uint256) {
return sample.decodeUint31(_TIMESTAMP_OFFSET);
}
function _instLogPairPrice(bytes32 sample) private pure returns (int256) {
return sample.decodeInt22(_INST_LOG_PAIR_PRICE_OFFSET);
}
function _accLogPairPrice(bytes32 sample) private pure returns (int256) {
return sample.decodeInt53(_ACC_LOG_PAIR_PRICE_OFFSET);
}
function _instLogBptPrice(bytes32 sample) private pure returns (int256) {
return sample.decodeInt22(_INST_LOG_BPT_PRICE_OFFSET);
}
function _accLogBptPrice(bytes32 sample) private pure returns (int256) {
return sample.decodeInt53(_ACC_LOG_BPT_PRICE_OFFSET);
}
function _instLogInvariant(bytes32 sample) private pure returns (int256) {
return sample.decodeInt22(_INST_LOG_INVARIANT_OFFSET);
}
function _accLogInvariant(bytes32 sample) private pure returns (int256) {
return sample.decodeInt53(_ACC_LOG_INVARIANT_OFFSET);
}
function pack(
int256 instLogPairPrice,
int256 accLogPairPrice,
int256 instLogBptPrice,
int256 accLogBptPrice,
int256 instLogInvariant,
int256 accLogInvariant,
uint256 _timestamp
) internal pure returns (bytes32) {
return
instLogPairPrice.encodeInt22(_INST_LOG_PAIR_PRICE_OFFSET) |
accLogPairPrice.encodeInt53(_ACC_LOG_PAIR_PRICE_OFFSET) |
instLogBptPrice.encodeInt22(_INST_LOG_BPT_PRICE_OFFSET) |
accLogBptPrice.encodeInt53(_ACC_LOG_BPT_PRICE_OFFSET) |
instLogInvariant.encodeInt22(_INST_LOG_INVARIANT_OFFSET) |
accLogInvariant.encodeInt53(_ACC_LOG_INVARIANT_OFFSET) |
_timestamp.encodeUint(_TIMESTAMP_OFFSET);
}
function unpack(bytes32 sample)
internal
pure
returns (
int256 logPairPrice,
int256 accLogPairPrice,
int256 logBptPrice,
int256 accLogBptPrice,
int256 logInvariant,
int256 accLogInvariant,
uint256 _timestamp
)
{
logPairPrice = _instLogPairPrice(sample);
accLogPairPrice = _accLogPairPrice(sample);
logBptPrice = _instLogBptPrice(sample);
accLogBptPrice = _accLogBptPrice(sample);
logInvariant = _instLogInvariant(sample);
accLogInvariant = _accLogInvariant(sample);
_timestamp = timestamp(sample);
}
}
文件 31 的 32：Space.sol
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import { FixedPoint } from "@balancer-labs/v2-solidity-utils/contracts/math/FixedPoint.sol";
import { Math as BasicMath } from "@balancer-labs/v2-solidity-utils/contracts/math/Math.sol";
import { BalancerPoolToken } from "@balancer-labs/v2-pool-utils/contracts/BalancerPoolToken.sol";
import { ERC20 } from "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ERC20.sol";
import { LogCompression } from "@balancer-labs/v2-solidity-utils/contracts/helpers/LogCompression.sol";
import { IMinimalSwapInfoPool } from "@balancer-labs/v2-vault/contracts/interfaces/IMinimalSwapInfoPool.sol";
import { IVault } from "@balancer-labs/v2-vault/contracts/interfaces/IVault.sol";
import { IERC20 } from "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol";
import { Errors, _require } from "./Errors.sol";
import { PoolPriceOracle } from "./oracle/PoolPriceOracle.sol";
interface AdapterLike {
function scale() external returns (uint256);
function scaleStored() external view returns (uint256);
function target() external view returns (address);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getUnderlyingPrice() external view returns (uint256);
}
contract Space is IMinimalSwapInfoPool, BalancerPoolToken, PoolPriceOracle {
using FixedPoint for uint256;
struct OracleData {
uint16 oracleIndex;
uint32 oracleSampleInitialTimestamp;
bool oracleEnabled;
int200 logInvariant;
}
uint256 public constant MINIMUM_BPT = 1e6;
address public immutable adapter;
uint256 public immutable maturity;
uint256 public immutable pti;
uint256 public immutable ts;
uint256 public immutable g1;
uint256 public immutable g2;
bytes32 internal immutable _poolId;
IERC20 internal immutable _token0;
IERC20 internal immutable _token1;
uint256 internal immutable _scalingFactorPT;
uint256 internal immutable _scalingFactorTarget;
IVault internal immutable _vault;
address internal immutable _protocolFeesCollector;
uint256 internal _initScale;
uint256 internal _lastToken0Reserve;
uint256 internal _lastToken1Reserve;
OracleData internal oracleData;
constructor(
IVault vault,
address _adapter,
uint256 _maturity,
address pt,
uint256 _ts,
uint256 _g1,
uint256 _g2,
bool _oracleEnabled
) BalancerPoolToken(
string(abi.encodePacked("Sense Space ", ERC20(pt).name())),
string(abi.encodePacked("SPACE-", ERC20(pt).symbol()))
) {
bytes32 poolId = vault.registerPool(IVault.PoolSpecialization.TWO_TOKEN);
address target = AdapterLike(_adapter).target();
IERC20[] memory tokens = new IERC20[](2);
uint256 _pti = pt < target ? 0 : 1;
tokens[_pti] = IERC20(pt);
tokens[1 - _pti] = IERC20(target);
vault.registerTokens(poolId, tokens, new address[](2));
_vault = vault;
_poolId = poolId;
_token0 = tokens[0];
_token1 = tokens[1];
_protocolFeesCollector = address(vault.getProtocolFeesCollector());
_scalingFactorPT = 10**(BasicMath.sub(uint256(18), ERC20(pt).decimals()));
_scalingFactorTarget = 10**(BasicMath.sub(uint256(18), ERC20(target).decimals()));
g1 = _g1;
g2 = _g2;
ts = _ts;
pti = _pti;
adapter = _adapter;
maturity = _maturity;
oracleData.oracleEnabled = _oracleEnabled;
}
function onJoinPool(
bytes32 poolId,
address,
address recipient,
uint256[] memory reserves,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) external override onlyVault(poolId) returns (uint256[] memory, uint256[] memory) {
_require(maturity >= block.timestamp, Errors.POOL_PAST_MATURITY);
(uint256[] memory reqAmountsIn, uint256 minBptOut) = abi.decode(userData, (uint256[], uint256));
_upscaleArray(reserves);
_upscaleArray(reqAmountsIn);
if (totalSupply() == 0) {
uint256 initScale = AdapterLike(adapter).scale();
uint256 underlyingIn = reqAmountsIn[1 - pti].mulDown(initScale);
_mintPoolTokens(address(0), MINIMUM_BPT);
uint256 bptToMint = underlyingIn.sub(MINIMUM_BPT);
_mintPoolTokens(recipient, bptToMint);
_require(bptToMint >= minBptOut, Errors.BPT_OUT_MIN_AMOUNT);
_downscaleUpArray(reqAmountsIn);
_initScale = initScale;
delete reqAmountsIn[pti];
reserves = reqAmountsIn;
_cacheReserves(reserves);
return (reqAmountsIn, new uint256[](2));
} else {
_updateOracle(lastChangeBlock, reserves[pti], reserves[1 - pti]);
if (protocolSwapFeePercentage != 0) {
_mintPoolTokens(_protocolFeesCollector, _bptFeeDue(reserves, protocolSwapFeePercentage));
}
(uint256 bptToMint, uint256[] memory amountsIn) = _tokensInForBptOut(reqAmountsIn, reserves);
_require(bptToMint >= minBptOut, Errors.BPT_OUT_MIN_AMOUNT);
_mintPoolTokens(recipient, bptToMint);
reserves[0] += amountsIn[0];
reserves[1] += amountsIn[1];
_cacheReserves(reserves);
_downscaleUpArray(amountsIn);
return (amountsIn, new uint256[](2));
}
}
function onExitPool(
bytes32 poolId,
address sender,
address,
uint256[] memory reserves,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) external override onlyVault(poolId) returns (uint256[] memory, uint256[] memory) {
_upscaleArray(reserves);
_updateOracle(lastChangeBlock, reserves[pti], reserves[1 - pti]);
if (protocolSwapFeePercentage != 0) {
_mintPoolTokens(_protocolFeesCollector, _bptFeeDue(reserves, protocolSwapFeePercentage));
}
uint256 bptAmountIn = abi.decode(userData, (uint256));
uint256[] memory amountsOut = new uint256[](2);
uint256 _totalSupply = totalSupply();
amountsOut[0] = reserves[0].mulUp(bptAmountIn).divUp(_totalSupply);
amountsOut[1] = reserves[1].mulUp(bptAmountIn).divUp(_totalSupply);
_burnPoolTokens(sender, bptAmountIn);
reserves[0] = reserves[0].sub(amountsOut[0]);
reserves[1] = reserves[1].sub(amountsOut[1]);
_cacheReserves(reserves);
_downscaleDownArray(amountsOut);
return (amountsOut, new uint256[](2));
}
function onSwap(
SwapRequest memory request,
uint256 reservesTokenIn,
uint256 reservesTokenOut
) external override returns (uint256) {
bool pTIn = request.tokenIn == _token0 ? pti == 0 : pti == 1;
uint256 scalingFactorTokenIn = _scalingFactor(pTIn);
uint256 scalingFactorTokenOut = _scalingFactor(!pTIn);
reservesTokenIn = _upscale(reservesTokenIn, scalingFactorTokenIn);
reservesTokenOut = _upscale(reservesTokenOut, scalingFactorTokenOut);
if (msg.sender == address(getVault())) {
_updateOracle(
request.lastChangeBlock,
pTIn ? reservesTokenIn : reservesTokenOut,
pTIn ? reservesTokenOut: reservesTokenIn
);
}
uint256 scale = AdapterLike(adapter).scale();
if (pTIn) {
reservesTokenIn = reservesTokenIn.add(totalSupply());
reservesTokenOut = reservesTokenOut.mulDown(_initScale);
} else {
reservesTokenIn = reservesTokenIn.mulDown(_initScale);
reservesTokenOut = reservesTokenOut.add(totalSupply());
}
if (request.kind == IVault.SwapKind.GIVEN_IN) {
request.amount = _upscale(request.amount, scalingFactorTokenIn);
if (!pTIn) {
request.amount = request.amount.mulDown(scale);
}
uint256 amountOut = _onSwap(pTIn, true, request.amount, reservesTokenIn, reservesTokenOut);
if (pTIn) {
amountOut = amountOut.divDown(scale);
}
return _downscaleDown(amountOut, scalingFactorTokenOut);
} else {
request.amount = _upscale(request.amount, scalingFactorTokenOut);
if (pTIn) {
request.amount = request.amount.mulDown(scale);
}
uint256 amountIn = _onSwap(pTIn, false, request.amount, reservesTokenIn, reservesTokenOut);
if (!pTIn) {
amountIn = amountIn.divDown(scale);
}
return _downscaleUp(amountIn, scalingFactorTokenIn);
}
}
function _tokensInForBptOut(uint256[] memory reqAmountsIn, uint256[] memory reserves)
internal
view
returns (uint256, uint256[] memory)
{
(uint256 pTReserves, uint256 targetReserves) = (reserves[pti], reserves[1 - pti]);
uint256[] memory amountsIn = new uint256[](2);
if (pTReserves == 0) {
uint256 reqTargetIn = reqAmountsIn[1 - pti];
uint256 bptToMint = reqTargetIn.mulDown(_initScale);
amountsIn[1 - pti] = reqTargetIn;
return (bptToMint, amountsIn);
} else {
(uint256 reqPTIn, uint256 reqTargetIn) = (reqAmountsIn[pti], reqAmountsIn[1 - pti]);
uint256 _totalSupply = totalSupply();
uint256 bptToMintTarget = BasicMath.mul(_totalSupply, reqTargetIn) / targetReserves;
uint256 bptToMintPT = BasicMath.mul(_totalSupply, reqPTIn) / pTReserves;
if (bptToMintTarget < bptToMintPT) {
amountsIn[pti] = BasicMath.mul(pTReserves, reqTargetIn) / targetReserves;
amountsIn[1 - pti] = reqTargetIn;
return (bptToMintTarget, amountsIn);
} else {
amountsIn[pti] = reqPTIn;
amountsIn[1 - pti] = BasicMath.mul(targetReserves, reqPTIn) / pTReserves;
return (bptToMintPT, amountsIn);
}
}
}
function _onSwap(
bool pTIn,
bool givenIn,
uint256 amountDelta,
uint256 reservesTokenIn,
uint256 reservesTokenOut
) internal view returns (uint256) {
uint256 ttm = maturity > block.timestamp ? uint256(maturity - block.timestamp) * FixedPoint.ONE : 0;
uint256 t = ts.mulDown(ttm);
uint256 a = (pTIn ? g2 : g1).mulUp(t).complement();
uint256 x1 = reservesTokenIn.powUp(a);
uint256 y1 = reservesTokenOut.powUp(a);
uint256 newReservesTokenInOrOut = givenIn ? reservesTokenIn + amountDelta : reservesTokenOut.sub(amountDelta);
uint256 xOrY2 = newReservesTokenInOrOut.powDown(a);
uint256 xOrYPost = (x1.add(y1).sub(xOrY2)).powUp(FixedPoint.ONE.divDown(a));
_require(!givenIn || reservesTokenOut > xOrYPost, Errors.SWAP_TOO_SMALL);
if (givenIn) {
_require(
pTIn ?
newReservesTokenInOrOut >= xOrYPost :
newReservesTokenInOrOut <= xOrYPost,
Errors.NEGATIVE_RATE
);
return reservesTokenOut.sub(xOrYPost);
} else {
_require(
pTIn ?
xOrYPost >= newReservesTokenInOrOut :
xOrYPost <= newReservesTokenInOrOut,
Errors.NEGATIVE_RATE
);
return xOrYPost.sub(reservesTokenIn);
}
}
function _bptFeeDue(uint256[] memory reserves, uint256 protocolSwapFeePercentage) internal view returns (uint256) {
uint256 ttm = maturity > block.timestamp ? uint256(maturity - block.timestamp) * FixedPoint.ONE : 0;
uint256 a = ts.mulDown(ttm).complement();
uint256 timeOnlyInvariant = _lastToken0Reserve.powDown(a).add(_lastToken1Reserve.powDown(a));
uint256 x = reserves[pti].add(totalSupply()).powDown(a);
uint256 y = reserves[1 - pti].mulDown(_initScale).powDown(a);
uint256 fullInvariant = x.add(y);
if (fullInvariant <= timeOnlyInvariant) {
return 0;
}
uint256 growth = fullInvariant.divDown(timeOnlyInvariant).powDown(FixedPoint.ONE.divDown(a));
uint256 k = protocolSwapFeePercentage.mulDown(growth.sub(FixedPoint.ONE)).divDown(growth);
return totalSupply().mulDown(k).divDown(k.complement());
}
function _cacheReserves(uint256[] memory reserves) internal {
uint256 reservePT = reserves[pti].add(totalSupply());
uint256 reserveUnderlying = reserves[1 - pti].mulDown(_initScale);
uint256 lastToken0Reserve;
uint256 lastToken1Reserve;
if (pti == 0) {
lastToken0Reserve = reservePT;
lastToken1Reserve = reserveUnderlying;
} else {
lastToken0Reserve = reserveUnderlying;
lastToken1Reserve = reservePT;
}
if (oracleData.oracleEnabled) {
uint256 ttm = maturity > block.timestamp ? uint256(maturity - block.timestamp) * FixedPoint.ONE : 0;
uint256 a = ts.mulDown(ttm).complement();
oracleData.logInvariant = int200(
LogCompression.toLowResLog(
lastToken0Reserve.powDown(a).add(lastToken1Reserve.powDown(a))
)
);
}
_lastToken0Reserve = lastToken0Reserve;
_lastToken1Reserve = lastToken1Reserve;
}
function _updateOracle(
uint256 lastChangeBlock,
uint256 balancePT,
uint256 balanceTarget
) internal {
if (oracleData.oracleEnabled && block.number > lastChangeBlock && balanceTarget >= 1e16) {
uint256 impliedRate = balancePT.add(totalSupply())
.divDown(balanceTarget.mulDown(_initScale));
impliedRate = impliedRate < FixedPoint.ONE ? 0 : impliedRate.sub(FixedPoint.ONE);
uint256 pTPriceInTarget = getPriceFromImpliedRate(impliedRate);
uint256 pairPrice = pti == 0 ? FixedPoint.ONE.divDown(pTPriceInTarget) : pTPriceInTarget;
uint256 oracleUpdatedIndex = _processPriceData(
oracleData.oracleSampleInitialTimestamp,
oracleData.oracleIndex,
LogCompression.toLowResLog(pairPrice),
impliedRate < 1e6 ? LogCompression.toLowResLog(1e6) : LogCompression.toLowResLog(impliedRate),
int256(oracleData.logInvariant)
);
if (oracleData.oracleIndex != oracleUpdatedIndex) {
oracleData.oracleSampleInitialTimestamp = uint32(block.timestamp);
oracleData.oracleIndex = uint16(oracleUpdatedIndex);
}
}
}
function _getOracleIndex() internal view override returns (uint256) {
return oracleData.oracleIndex;
}
function getImpliedRateFromPrice(uint256 pTPriceInTarget) public view returns (uint256 impliedRate) {
if (block.timestamp >= maturity) {
return 0;
}
impliedRate = FixedPoint.ONE
.divDown(pTPriceInTarget.mulDown(AdapterLike(adapter).scaleStored()))
.powDown(FixedPoint.ONE.divDown(ts).divDown((maturity - block.timestamp) * FixedPoint.ONE))
.sub(FixedPoint.ONE);
}
function getPriceFromImpliedRate(uint256 impliedRate) public view returns (uint256 pTPriceInTarget) {
if (block.timestamp >= maturity) {
return FixedPoint.ONE;
}
pTPriceInTarget = FixedPoint.ONE
.divDown(impliedRate.add(FixedPoint.ONE)
.powDown(((maturity - block.timestamp) * FixedPoint.ONE)
.divDown(FixedPoint.ONE.divDown(ts))))
.divDown(AdapterLike(adapter).scaleStored());
}
function getFairBPTPrice(uint256 ptTwapDuration)
public
view
returns (uint256 fairBptPriceInTarget)
{
OracleAverageQuery[] memory queries = new OracleAverageQuery[](1);
queries[0] = OracleAverageQuery({
variable: Variable.PAIR_PRICE,
secs: ptTwapDuration,
ago: 1 hours
});
uint256[] memory results = this.getTimeWeightedAverage(queries);
uint256 pTPriceInTarget = pti == 1 ? results[0] : FixedPoint.ONE.divDown(results[0]);
uint256 impliedRate = getImpliedRateFromPrice(pTPriceInTarget);
(, uint256[] memory balances, ) = _vault.getPoolTokens(_poolId);
uint256 ttm = maturity > block.timestamp
? uint256(maturity - block.timestamp) * FixedPoint.ONE
: 0;
uint256 a = ts.mulDown(ttm).complement();
uint256 k = balances[pti].add(totalSupply()).powDown(a).add(
balances[1 - pti].mulDown(_initScale).powDown(a)
);
uint256 equilibriumPTReservesPartial = k.divDown(
FixedPoint.ONE.divDown(FixedPoint.ONE.add(impliedRate).powDown(a)).add(FixedPoint.ONE)
).powDown(FixedPoint.ONE.divDown(a));
uint256 equilibriumTargetReserves = equilibriumPTReservesPartial
.divDown(_initScale.mulDown(FixedPoint.ONE.add(impliedRate)));
fairBptPriceInTarget = equilibriumTargetReserves
.add(equilibriumPTReservesPartial.sub(totalSupply())
.mulDown(pTPriceInTarget)).divDown(totalSupply());
}
function getIndices() public view returns (uint256 _pti, uint256 _targeti) {
_pti = pti;
_targeti = 1 - pti;
}
function getPoolId() public view override returns (bytes32) {
return _poolId;
}
function getVault() public view returns (IVault) {
return _vault;
}
function _scalingFactor(bool pt) internal view returns (uint256) {
return pt ? _scalingFactorPT : _scalingFactorTarget;
}
function _upscale(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
return BasicMath.mul(amount, scalingFactor);
}
function _downscaleDown(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
return amount / scalingFactor;
}
function _downscaleUp(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
return BasicMath.divUp(amount, scalingFactor);
}
function _upscaleArray(uint256[] memory amounts) internal view {
amounts[pti] = BasicMath.mul(amounts[pti], _scalingFactor(true));
amounts[1 - pti] = BasicMath.mul(amounts[1 - pti], _scalingFactor(false));
}
function _downscaleDownArray(uint256[] memory amounts) internal view {
amounts[pti] = amounts[pti] / _scalingFactor(true);
amounts[1 - pti] = amounts[1 - pti] / _scalingFactor(false);
}
function _downscaleUpArray(uint256[] memory amounts) internal view {
amounts[pti] = BasicMath.divUp(amounts[pti], _scalingFactor(true));
amounts[1 - pti] = BasicMath.divUp(amounts[1 - pti], _scalingFactor(false));
}
modifier onlyVault(bytes32 poolId_) {
_require(msg.sender == address(getVault()), Errors.CALLER_NOT_VAULT);
_require(poolId_ == getPoolId(), Errors.INVALID_POOL_ID);
_;
}
}
文件 32 的 32：WordCodec.sol
pragma solidity ^0.7.0;
library WordCodec {
uint256 private constant _MASK_1 = 2**(1) - 1;
uint256 private constant _MASK_5 = 2**(5) - 1;
uint256 private constant _MASK_7 = 2**(7) - 1;
uint256 private constant _MASK_10 = 2**(10) - 1;
uint256 private constant _MASK_16 = 2**(16) - 1;
uint256 private constant _MASK_22 = 2**(22) - 1;
uint256 private constant _MASK_31 = 2**(31) - 1;
uint256 private constant _MASK_32 = 2**(32) - 1;
uint256 private constant _MASK_53 = 2**(53) - 1;
uint256 private constant _MASK_64 = 2**(64) - 1;
uint256 private constant _MASK_128 = 2**(128) - 1;
uint256 private constant _MASK_192 = 2**(192) - 1;
int256 private constant _MAX_INT_22 = 2**(21) - 1;
int256 private constant _MAX_INT_53 = 2**(52) - 1;
function insertBool(
bytes32 word,
bool value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_1 << offset));
return clearedWord | bytes32(uint256(value ? 1 : 0) << offset);
}
function insertUint5(
bytes32 word,
uint256 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_5 << offset));
return clearedWord | bytes32(value << offset);
}
function insertUint7(
bytes32 word,
uint256 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_7 << offset));
return clearedWord | bytes32(value << offset);
}
function insertUint10(
bytes32 word,
uint256 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_10 << offset));
return clearedWord | bytes32(value << offset);
}
function insertUint16(
bytes32 word,
uint256 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_16 << offset));
return clearedWord | bytes32(value << offset);
}
function insertUint31(
bytes32 word,
uint256 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_31 << offset));
return clearedWord | bytes32(value << offset);
}
function insertUint32(
bytes32 word,
uint256 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_32 << offset));
return clearedWord | bytes32(value << offset);
}
function insertUint64(
bytes32 word,
uint256 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_64 << offset));
return clearedWord | bytes32(value << offset);
}
function insertInt22(
bytes32 word,
int256 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_22 << offset));
return clearedWord | bytes32((uint256(value) & _MASK_22) << offset);
}
function insertBits192(
bytes32 word,
bytes32 value,
uint256 offset
) internal pure returns (bytes32) {
bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_192 << offset));
return clearedWord | bytes32((uint256(value) & _MASK_192) << offset);
}
function encodeUint(uint256 value, uint256 offset) internal pure returns (bytes32) {
return bytes32(value << offset);
}
function encodeInt22(int256 value, uint256 offset) internal pure returns (bytes32) {
return bytes32((uint256(value) & _MASK_22) << offset);
}
function encodeInt53(int256 value, uint256 offset) internal pure returns (bytes32) {
return bytes32((uint256(value) & _MASK_53) << offset);
}
function decodeBool(bytes32 word, uint256 offset) internal pure returns (bool) {
return (uint256(word >> offset) & _MASK_1) == 1;
}
function decodeUint5(bytes32 word, uint256 offset) internal pure returns (uint256) {
return uint256(word >> offset) & _MASK_5;
}
function decodeUint7(bytes32 word, uint256 offset) internal pure returns (uint256) {
return uint256(word >> offset) & _MASK_7;
}
function decodeUint10(bytes32 word, uint256 offset) internal pure returns (uint256) {
return uint256(word >> offset) & _MASK_10;
}
function decodeUint16(bytes32 word, uint256 offset) internal pure returns (uint256) {
return uint256(word >> offset) & _MASK_16;
}
function decodeUint31(bytes32 word, uint256 offset) internal pure returns (uint256) {
return uint256(word >> offset) & _MASK_31;
}
function decodeUint32(bytes32 word, uint256 offset) internal pure returns (uint256) {
return uint256(word >> offset) & _MASK_32;
}
function decodeUint64(bytes32 word, uint256 offset) internal pure returns (uint256) {
return uint256(word >> offset) & _MASK_64;
}
function decodeUint128(bytes32 word, uint256 offset) internal pure returns (uint256) {
return uint256(word >> offset) & _MASK_128;
}
function decodeInt22(bytes32 word, uint256 offset) internal pure returns (int256) {
int256 value = int256(uint256(word >> offset) & _MASK_22);
return value > _MAX_INT_22 ? (value | int256(~_MASK_22)) : value;
}
function decodeInt53(bytes32 word, uint256 offset) internal pure returns (int256) {
int256 value = int256(uint256(word >> offset) & _MASK_53);
return value > _MAX_INT_53 ? (value | int256(~_MASK_53)) : value;
}
}
{
"compilationTarget": {
"lib/v1-space/src/Space.sol": "Space"
},
"evmVersion": "istanbul",
"libraries": {
"lib/v1-space/src/oracle/QueryProcessor.sol:QueryProcessor": "0xcbe8c43a6e3be093489b5b1bff2e851d01d451f6"
},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 500
},
"remappings": []
}[{"inputs":[{"internalType":"contract IVault","name":"vault","type":"address"},{"internalType":"address","name":"_adapter","type":"address"},{"internalType":"uint256","name":"_maturity","type":"uint256"},{"internalType":"address","name":"pt","type":"address"},{"internalType":"uint256","name":"_ts","type":"uint256"},{"internalType":"uint256","name":"_g1","type":"uint256"},{"internalType":"uint256","name":"_g2","type":"uint256"},{"internalType":"bool","name":"_oracleEnabled","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINIMUM_BPT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"adapter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"startIndex","type":"uint256"},{"internalType":"uint256","name":"endIndex","type":"uint256"}],"name":"dirtyUninitializedOracleSamples","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"g1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"g2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"ptTwapDuration","type":"uint256"}],"name":"getFairBPTPrice","outputs":[{"internalType":"uint256","name":"fairBptPriceInTarget","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pTPriceInTarget","type":"uint256"}],"name":"getImpliedRateFromPrice","outputs":[{"internalType":"uint256","name":"impliedRate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getIndices","outputs":[{"internalType":"uint256","name":"_pti","type":"uint256"},{"internalType":"uint256","name":"_targeti","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLargestSafeQueryWindow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"enum IPriceOracle.Variable","name":"variable","type":"uint8"}],"name":"getLatest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"enum IPriceOracle.Variable","name":"variable","type":"uint8"},{"internalType":"uint256","name":"ago","type":"uint256"}],"internalType":"struct IPriceOracle.OracleAccumulatorQuery[]","name":"queries","type":"tuple[]"}],"name":"getPastAccumulators","outputs":[{"internalType":"int256[]","name":"results","type":"int256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPoolId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"impliedRate","type":"uint256"}],"name":"getPriceFromImpliedRate","outputs":[{"internalType":"uint256","name":"pTPriceInTarget","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getSample","outputs":[{"internalType":"int256","name":"logPairPrice","type":"int256"},{"internalType":"int256","name":"accLogPairPrice","type":"int256"},{"internalType":"int256","name":"logBptPrice","type":"int256"},{"internalType":"int256","name":"accLogBptPrice","type":"int256"},{"internalType":"int256","name":"logInvariant","type":"int256"},{"internalType":"int256","name":"accLogInvariant","type":"int256"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"enum IPriceOracle.Variable","name":"variable","type":"uint8"},{"internalType":"uint256","name":"secs","type":"uint256"},{"internalType":"uint256","name":"ago","type":"uint256"}],"internalType":"struct IPriceOracle.OracleAverageQuery[]","name":"queries","type":"tuple[]"}],"name":"getTimeWeightedAverage","outputs":[{"internalType":"uint256[]","name":"results","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalSamples","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getVault","outputs":[{"internalType":"contract IVault","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maturity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"reserves","type":"uint256[]"},{"internalType":"uint256","name":"lastChangeBlock","type":"uint256"},{"internalType":"uint256","name":"protocolSwapFeePercentage","type":"uint256"},{"internalType":"bytes","name":"userData","type":"bytes"}],"name":"onExitPool","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256[]","name":"reserves","type":"uint256[]"},{"internalType":"uint256","name":"lastChangeBlock","type":"uint256"},{"internalType":"uint256","name":"protocolSwapFeePercentage","type":"uint256"},{"internalType":"bytes","name":"userData","type":"bytes"}],"name":"onJoinPool","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"enum IVault.SwapKind","name":"kind","type":"uint8"},{"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"internalType":"contract IERC20","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"uint256","name":"lastChangeBlock","type":"uint256"},{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"bytes","name":"userData","type":"bytes"}],"internalType":"struct IPoolSwapStructs.SwapRequest","name":"request","type":"tuple"},{"internalType":"uint256","name":"reservesTokenIn","type":"uint256"},{"internalType":"uint256","name":"reservesTokenOut","type":"uint256"}],"name":"onSwap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pti","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
