编译器
0.8.20+commit.a1b79de6
文件 1 的 33：Address.sol
pragma solidity ^0.8.20;
library Address {
error AddressInsufficientBalance(address account);
error AddressEmptyCode(address target);
error FailedInnerCall();
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
function _revert(bytes memory returndata) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}
文件 2 的 33：Arrays.sol
pragma solidity ^0.8.20;
import {StorageSlot} from "./StorageSlot.sol";
import {Math} from "./math/Math.sol";
library Arrays {
using StorageSlot for bytes32;
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
uint256 low = 0;
uint256 high = array.length;
if (high == 0) {
return 0;
}
while (low < high) {
uint256 mid = Math.average(low, high);
if (unsafeAccess(array, mid).value > element) {
high = mid;
} else {
low = mid + 1;
}
}
if (low > 0 && unsafeAccess(array, low - 1).value == element) {
return low - 1;
} else {
return low;
}
}
function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
bytes32 slot;
assembly {
mstore(0, arr.slot)
slot := add(keccak256(0, 0x20), pos)
}
return slot.getAddressSlot();
}
function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
bytes32 slot;
assembly {
mstore(0, arr.slot)
slot := add(keccak256(0, 0x20), pos)
}
return slot.getBytes32Slot();
}
function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
bytes32 slot;
assembly {
mstore(0, arr.slot)
slot := add(keccak256(0, 0x20), pos)
}
return slot.getUint256Slot();
}
function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
assembly {
res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
}
}
function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) {
assembly {
res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
}
}
}
文件 3 的 33：Context.sol
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 4 的 33：ECDSA.sol
pragma solidity ^0.8.20;
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
error ECDSAInvalidSignature();
error ECDSAInvalidSignatureLength(uint256 length);
error ECDSAInvalidSignatureS(bytes32 s);
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError, bytes32) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}
文件 5 的 33：EIP712.sol
pragma solidity ^0.8.20;
import {MessageHashUtils} from "./MessageHashUtils.sol";
import {ShortStrings, ShortString} from "../ShortStrings.sol";
import {IERC5267} from "../../interfaces/IERC5267.sol";
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
function _EIP712Name() internal view returns (string memory) {
return _name.toStringWithFallback(_nameFallback);
}
function _EIP712Version() internal view returns (string memory) {
return _version.toStringWithFallback(_versionFallback);
}
}
文件 6 的 33：ERC1155.sol
pragma solidity ^0.8.20;
import {IERC1155} from "./IERC1155.sol";
import {IERC1155Receiver} from "./IERC1155Receiver.sol";
import {IERC1155MetadataURI} from "./extensions/IERC1155MetadataURI.sol";
import {Context} from "../../utils/Context.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {Arrays} from "../../utils/Arrays.sol";
import {IERC1155Errors} from "../../interfaces/draft-IERC6093.sol";
abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC1155Errors {
using Arrays for uint256[];
using Arrays for address[];
mapping(uint256 id => mapping(address account => uint256)) private _balances;
mapping(address account => mapping(address operator => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256 ) public view virtual returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual returns (uint256) {
return _balances[id][account];
}
function balanceOfBatch(
address[] memory accounts,
uint256[] memory ids
) public view virtual returns (uint256[] memory) {
if (accounts.length != ids.length) {
revert ERC1155InvalidArrayLength(ids.length, accounts.length);
}
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts.unsafeMemoryAccess(i), ids.unsafeMemoryAccess(i));
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual {
address sender = _msgSender();
if (from != sender && !isApprovedForAll(from, sender)) {
revert ERC1155MissingApprovalForAll(sender, from);
}
_safeTransferFrom(from, to, id, value, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory values,
bytes memory data
) public virtual {
address sender = _msgSender();
if (from != sender && !isApprovedForAll(from, sender)) {
revert ERC1155MissingApprovalForAll(sender, from);
}
_safeBatchTransferFrom(from, to, ids, values, data);
}
function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual {
if (ids.length != values.length) {
revert ERC1155InvalidArrayLength(ids.length, values.length);
}
address operator = _msgSender();
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids.unsafeMemoryAccess(i);
uint256 value = values.unsafeMemoryAccess(i);
if (from != address(0)) {
uint256 fromBalance = _balances[id][from];
if (fromBalance < value) {
revert ERC1155InsufficientBalance(from, fromBalance, value, id);
}
unchecked {
_balances[id][from] = fromBalance - value;
}
}
if (to != address(0)) {
_balances[id][to] += value;
}
}
if (ids.length == 1) {
uint256 id = ids.unsafeMemoryAccess(0);
uint256 value = values.unsafeMemoryAccess(0);
emit TransferSingle(operator, from, to, id, value);
} else {
emit TransferBatch(operator, from, to, ids, values);
}
}
function _updateWithAcceptanceCheck(
address from,
address to,
uint256[] memory ids,
uint256[] memory values,
bytes memory data
) internal virtual {
_update(from, to, ids, values);
if (to != address(0)) {
address operator = _msgSender();
if (ids.length == 1) {
uint256 id = ids.unsafeMemoryAccess(0);
uint256 value = values.unsafeMemoryAccess(0);
_doSafeTransferAcceptanceCheck(operator, from, to, id, value, data);
} else {
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, values, data);
}
}
}
function _safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) internal {
if (to == address(0)) {
revert ERC1155InvalidReceiver(address(0));
}
if (from == address(0)) {
revert ERC1155InvalidSender(address(0));
}
(uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
_updateWithAcceptanceCheck(from, to, ids, values, data);
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory values,
bytes memory data
) internal {
if (to == address(0)) {
revert ERC1155InvalidReceiver(address(0));
}
if (from == address(0)) {
revert ERC1155InvalidSender(address(0));
}
_updateWithAcceptanceCheck(from, to, ids, values, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address to, uint256 id, uint256 value, bytes memory data) internal {
if (to == address(0)) {
revert ERC1155InvalidReceiver(address(0));
}
(uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
_updateWithAcceptanceCheck(address(0), to, ids, values, data);
}
function _mintBatch(address to, uint256[] memory ids, uint256[] memory values, bytes memory data) internal {
if (to == address(0)) {
revert ERC1155InvalidReceiver(address(0));
}
_updateWithAcceptanceCheck(address(0), to, ids, values, data);
}
function _burn(address from, uint256 id, uint256 value) internal {
if (from == address(0)) {
revert ERC1155InvalidSender(address(0));
}
(uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
_updateWithAcceptanceCheck(from, address(0), ids, values, "");
}
function _burnBatch(address from, uint256[] memory ids, uint256[] memory values) internal {
if (from == address(0)) {
revert ERC1155InvalidSender(address(0));
}
_updateWithAcceptanceCheck(from, address(0), ids, values, "");
}
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
if (operator == address(0)) {
revert ERC1155InvalidOperator(address(0));
}
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 value,
bytes memory data
) private {
if (to.code.length > 0) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, value, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert ERC1155InvalidReceiver(to);
}
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ERC1155InvalidReceiver(to);
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory values,
bytes memory data
) private {
if (to.code.length > 0) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, values, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert ERC1155InvalidReceiver(to);
}
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ERC1155InvalidReceiver(to);
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
}
function _asSingletonArrays(
uint256 element1,
uint256 element2
) private pure returns (uint256[] memory array1, uint256[] memory array2) {
assembly {
array1 := mload(0x40)
mstore(array1, 1)
mstore(add(array1, 0x20), element1)
array2 := add(array1, 0x40)
mstore(array2, 1)
mstore(add(array2, 0x20), element2)
mstore(0x40, add(array2, 0x40))
}
}
}
文件 7 的 33：ERC165.sol
pragma solidity ^0.8.20;
import {IERC165} from "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 8 的 33：ERC20.sol
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
_totalSupply -= value;
}
} else {
unchecked {
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
文件 9 的 33：FixedPointMathLib.sol
pragma solidity ^0.8.4;
library FixedPointMathLib {
error ExpOverflow();
error FactorialOverflow();
error RPowOverflow();
error MantissaOverflow();
error MulWadFailed();
error SMulWadFailed();
error DivWadFailed();
error SDivWadFailed();
error MulDivFailed();
error DivFailed();
error FullMulDivFailed();
error LnWadUndefined();
error OutOfDomain();
uint256 internal constant WAD = 1e18;
function mulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if mul(y, gt(x, div(not(0), y))) {
mstore(0x00, 0xbac65e5b)
revert(0x1c, 0x04)
}
z := div(mul(x, y), WAD)
}
}
function sMulWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := mul(x, y)
if iszero(gt(or(iszero(x), eq(sdiv(z, x), y)), lt(not(x), eq(y, shl(255, 1))))) {
mstore(0x00, 0xedcd4dd4)
revert(0x1c, 0x04)
}
z := sdiv(z, WAD)
}
}
function rawMulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(mul(x, y), WAD)
}
}
function rawSMulWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(mul(x, y), WAD)
}
}
function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if mul(y, gt(x, div(not(0), y))) {
mstore(0x00, 0xbac65e5b)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(mul(x, y), WAD))), div(mul(x, y), WAD))
}
}
function rawMulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(iszero(iszero(mod(mul(x, y), WAD))), div(mul(x, y), WAD))
}
}
function divWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if iszero(mul(y, iszero(mul(WAD, gt(x, div(not(0), WAD)))))) {
mstore(0x00, 0x7c5f487d)
revert(0x1c, 0x04)
}
z := div(mul(x, WAD), y)
}
}
function sDivWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := mul(x, WAD)
if iszero(and(iszero(iszero(y)), eq(sdiv(z, WAD), x))) {
mstore(0x00, 0x5c43740d)
revert(0x1c, 0x04)
}
z := sdiv(mul(x, WAD), y)
}
}
function rawDivWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(mul(x, WAD), y)
}
}
function rawSDivWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(mul(x, WAD), y)
}
}
function divWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if iszero(mul(y, iszero(mul(WAD, gt(x, div(not(0), WAD)))))) {
mstore(0x00, 0x7c5f487d)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
function rawDivWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
function powWad(int256 x, int256 y) internal pure returns (int256) {
return expWad((lnWad(x) * y) / int256(WAD));
}
function expWad(int256 x) internal pure returns (int256 r) {
unchecked {
if (x <= -41446531673892822313) return r;
assembly {
if iszero(slt(x, 135305999368893231589)) {
mstore(0x00, 0xa37bfec9)
revert(0x1c, 0x04)
}
}
x = (x << 78) / 5 ** 18;
int256 k = ((x << 96) / 54916777467707473351141471128 + 2 ** 95) >> 96;
x = x - k * 54916777467707473351141471128;
int256 y = x + 1346386616545796478920950773328;
y = ((y * x) >> 96) + 57155421227552351082224309758442;
int256 p = y + x - 94201549194550492254356042504812;
p = ((p * y) >> 96) + 28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276 << 96);
int256 q = x - 2855989394907223263936484059900;
q = ((q * x) >> 96) + 50020603652535783019961831881945;
q = ((q * x) >> 96) - 533845033583426703283633433725380;
q = ((q * x) >> 96) + 3604857256930695427073651918091429;
q = ((q * x) >> 96) - 14423608567350463180887372962807573;
q = ((q * x) >> 96) + 26449188498355588339934803723976023;
assembly {
r := sdiv(p, q)
}
r = int256(
(uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k)
);
}
}
function lnWad(int256 x) internal pure returns (int256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
if iszero(sgt(x, 0)) {
mstore(0x00, 0x1615e638)
revert(0x1c, 0x04)
}
r := xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff))
x := shr(159, shl(r, x))
let p := sub(
sar(96, mul(add(43456485725739037958740375743393,
sar(96, mul(add(24828157081833163892658089445524,
sar(96, mul(add(3273285459638523848632254066296,
x), x))), x))), x)), 11111509109440967052023855526967)
p := sub(sar(96, mul(p, x)), 45023709667254063763336534515857)
p := sub(sar(96, mul(p, x)), 14706773417378608786704636184526)
p := sub(mul(p, x), shl(96, 795164235651350426258249787498))
let q := add(5573035233440673466300451813936, x)
q := add(71694874799317883764090561454958, sar(96, mul(x, q)))
q := add(283447036172924575727196451306956, sar(96, mul(x, q)))
q := add(401686690394027663651624208769553, sar(96, mul(x, q)))
q := add(204048457590392012362485061816622, sar(96, mul(x, q)))
q := add(31853899698501571402653359427138, sar(96, mul(x, q)))
q := add(909429971244387300277376558375, sar(96, mul(x, q)))
p := sdiv(p, q)
p := mul(1677202110996718588342820967067443963516166, p)
p := add(mul(16597577552685614221487285958193947469193820559219878177908093499208371, sub(159, r)), p)
p := add(600920179829731861736702779321621459595472258049074101567377883020018308, p)
r := sar(174, p)
}
}
function lambertW0Wad(int256 x) internal pure returns (int256 w) {
unchecked {
if ((w = x) <= -367879441171442322) revert OutOfDomain();
int256 wad = int256(WAD);
int256 p = x;
uint256 c;
uint256 i = 4;
if (w <= 0x1ffffffffffff) {
if (-0x4000000000000 <= w) {
i = 1;
} else if (w <= -0x3ffffffffffffff) {
i = 32;
}
} else if (uint256(w >> 63) == uint256(0)) {
assembly {
let v := shr(49, w)
let l := shl(3, lt(0xff, v))
l := add(or(l, byte(and(0x1f, shr(shr(l, v), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000)), 49)
w := sdiv(shl(l, 7), byte(sub(l, 31), 0x0303030303030303040506080c13))
c := gt(l, 60)
i := add(2, add(gt(l, 53), c))
}
} else {
int256 ll = lnWad(w = lnWad(w));
assembly {
w := add(sdiv(mul(ll, 1023715080943847266), w), sub(w, ll))
i := add(3, iszero(shr(68, x)))
c := iszero(shr(143, x))
}
if (c == uint256(0)) {
do {
int256 e = expWad(w);
assembly {
let t := mul(w, div(e, wad))
w := sub(w, sdiv(sub(t, x), div(add(e, t), wad)))
}
if (p <= w) break;
p = w;
} while (--i != uint256(0));
assembly {
w := sub(w, sgt(w, 2))
}
return w;
}
}
do {
int256 e = expWad(w);
assembly {
let t := add(w, wad)
let s := sub(mul(w, e), mul(x, wad))
w := sub(w, sdiv(mul(s, wad), sub(mul(e, t), sdiv(mul(add(t, wad), s), add(t, t)))))
}
if (p <= w) break;
p = w;
} while (--i != c);
assembly {
w := sub(w, sgt(w, 2))
}
if (c == uint256(0)) return w;
int256 t = w | 1;
assembly {
x := sdiv(mul(x, wad), t)
}
x = (t * (wad + lnWad(x)));
assembly {
w := sdiv(x, add(wad, t))
}
}
}
function fullMulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {
assembly {
result := mul(x, y)
for {} 1 {} {
if iszero(mul(or(iszero(x), eq(div(result, x), y)), d)) {
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(result, lt(mm, result)))
let r := mulmod(x, y, d)
let t := and(d, sub(0, d))
if iszero(gt(d, p1)) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
result :=
mul(
or(
mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)),
div(sub(result, r), t)
),
mul(sub(2, mul(d, inv)), inv)
)
break
}
result := div(result, d)
break
}
}
}
function fullMulDivUnchecked(uint256 x, uint256 y, uint256 d)
internal
pure
returns (uint256 result)
{
assembly {
result := mul(x, y)
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(result, lt(mm, result)))
let t := and(d, sub(0, d))
let r := mulmod(x, y, d)
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
result :=
mul(
or(mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)), div(sub(result, r), t)),
mul(sub(2, mul(d, inv)), inv)
)
}
}
function fullMulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 result) {
result = fullMulDiv(x, y, d);
assembly {
if mulmod(x, y, d) {
result := add(result, 1)
if iszero(result) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
}
}
}
function mulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := div(z, d)
}
}
function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(z, d))), div(z, d))
}
}
function divUp(uint256 x, uint256 d) internal pure returns (uint256 z) {
assembly {
if iszero(d) {
mstore(0x00, 0x65244e4e)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(x, d))), div(x, d))
}
}
function zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
function ternary(bool condition, uint256 x, uint256 y) internal pure returns (uint256 result) {
assembly {
result := xor(x, mul(xor(x, y), iszero(condition)))
}
}
function rpow(uint256 x, uint256 y, uint256 b) internal pure returns (uint256 z) {
assembly {
z := mul(b, iszero(y))
if x {
z := xor(b, mul(xor(b, x), and(y, 1)))
let half := shr(1, b)
for { y := shr(1, y) } y { y := shr(1, y) } {
let xx := mul(x, x)
let xxRound := add(xx, half)
if or(lt(xxRound, xx), shr(128, x)) {
mstore(0x00, 0x49f7642b)
revert(0x1c, 0x04)
}
x := div(xxRound, b)
if and(y, 1) {
let zx := mul(z, x)
let zxRound := add(zx, half)
if or(xor(div(zx, x), z), lt(zxRound, zx)) {
if x {
mstore(0x00, 0x49f7642b)
revert(0x1c, 0x04)
}
}
z := div(zxRound, b)
}
}
}
}
}
function sqrt(uint256 x) internal pure returns (uint256 z) {
assembly {
z := 181
let r := shl(7, lt(0xffffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffffff, shr(r, x))))
z := shl(shr(1, r), z)
z := shr(18, mul(z, add(shr(r, x), 65536)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := sub(z, lt(div(x, z), z))
}
}
function cbrt(uint256 x) internal pure returns (uint256 z) {
assembly {
let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
z := div(shl(div(r, 3), shl(lt(0xf, shr(r, x)), 0xf)), xor(7, mod(r, 3)))
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := sub(z, lt(div(x, mul(z, z)), z))
}
}
function sqrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 18) return sqrt(x * 10 ** 18);
z = (1 + sqrt(x)) * 10 ** 9;
z = (fullMulDivUnchecked(x, 10 ** 18, z) + z) >> 1;
}
assembly {
z := sub(z, gt(999999999999999999, sub(mulmod(z, z, x), 1)))
}
}
function cbrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 36) return cbrt(x * 10 ** 36);
z = (1 + cbrt(x)) * 10 ** 12;
z = (fullMulDivUnchecked(x, 10 ** 36, z * z) + z + z) / 3;
x = fullMulDivUnchecked(x, 10 ** 36, z * z);
}
assembly {
z := sub(z, lt(x, z))
}
}
function factorial(uint256 x) internal pure returns (uint256 result) {
assembly {
result := 1
if iszero(lt(x, 58)) {
mstore(0x00, 0xaba0f2a2)
revert(0x1c, 0x04)
}
for {} x { x := sub(x, 1) } { result := mul(result, x) }
}
}
function log2(uint256 x) internal pure returns (uint256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000))
}
}
function log2Up(uint256 x) internal pure returns (uint256 r) {
r = log2(x);
assembly {
r := add(r, lt(shl(r, 1), x))
}
}
function log10(uint256 x) internal pure returns (uint256 r) {
assembly {
if iszero(lt(x, 100000000000000000000000000000000000000)) {
x := div(x, 100000000000000000000000000000000000000)
r := 38
}
if iszero(lt(x, 100000000000000000000)) {
x := div(x, 100000000000000000000)
r := add(r, 20)
}
if iszero(lt(x, 10000000000)) {
x := div(x, 10000000000)
r := add(r, 10)
}
if iszero(lt(x, 100000)) {
x := div(x, 100000)
r := add(r, 5)
}
r := add(r, add(gt(x, 9), add(gt(x, 99), add(gt(x, 999), gt(x, 9999)))))
}
}
function log10Up(uint256 x) internal pure returns (uint256 r) {
r = log10(x);
assembly {
r := add(r, lt(exp(10, r), x))
}
}
function log256(uint256 x) internal pure returns (uint256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(shr(3, r), lt(0xff, shr(r, x)))
}
}
function log256Up(uint256 x) internal pure returns (uint256 r) {
r = log256(x);
assembly {
r := add(r, lt(shl(shl(3, r), 1), x))
}
}
function sci(uint256 x) internal pure returns (uint256 mantissa, uint256 exponent) {
assembly {
mantissa := x
if mantissa {
if iszero(mod(mantissa, 1000000000000000000000000000000000)) {
mantissa := div(mantissa, 1000000000000000000000000000000000)
exponent := 33
}
if iszero(mod(mantissa, 10000000000000000000)) {
mantissa := div(mantissa, 10000000000000000000)
exponent := add(exponent, 19)
}
if iszero(mod(mantissa, 1000000000000)) {
mantissa := div(mantissa, 1000000000000)
exponent := add(exponent, 12)
}
if iszero(mod(mantissa, 1000000)) {
mantissa := div(mantissa, 1000000)
exponent := add(exponent, 6)
}
if iszero(mod(mantissa, 10000)) {
mantissa := div(mantissa, 10000)
exponent := add(exponent, 4)
}
if iszero(mod(mantissa, 100)) {
mantissa := div(mantissa, 100)
exponent := add(exponent, 2)
}
if iszero(mod(mantissa, 10)) {
mantissa := div(mantissa, 10)
exponent := add(exponent, 1)
}
}
}
}
function packSci(uint256 x) internal pure returns (uint256 packed) {
(x, packed) = sci(x);
assembly {
if shr(249, x) {
mstore(0x00, 0xce30380c)
revert(0x1c, 0x04)
}
packed := or(shl(7, x), packed)
}
}
function unpackSci(uint256 packed) internal pure returns (uint256 unpacked) {
unchecked {
unpacked = (packed >> 7) * 10 ** (packed & 0x7f);
}
}
function avg(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = (x & y) + ((x ^ y) >> 1);
}
}
function avg(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = (x >> 1) + (y >> 1) + (x & y & 1);
}
}
function abs(int256 x) internal pure returns (uint256 z) {
assembly {
z := xor(sar(255, x), add(sar(255, x), x))
}
}
function dist(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(mul(xor(sub(y, x), sub(x, y)), gt(x, y)), sub(y, x))
}
}
function dist(int256 x, int256 y) internal pure returns (uint256 z) {
assembly {
z := xor(mul(xor(sub(y, x), sub(x, y)), sgt(x, y)), sub(y, x))
}
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), lt(y, x)))
}
}
function min(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, y), slt(y, x)))
}
}
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), gt(y, x)))
}
}
function max(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, y), sgt(y, x)))
}
}
function clamp(uint256 x, uint256 minValue, uint256 maxValue)
internal
pure
returns (uint256 z)
{
assembly {
z := xor(x, mul(xor(x, minValue), gt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), lt(maxValue, z)))
}
}
function clamp(int256 x, int256 minValue, int256 maxValue) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, minValue), sgt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), slt(maxValue, z)))
}
}
function gcd(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
for { z := x } y {} {
let t := y
y := mod(z, y)
z := t
}
}
}
function lerp(uint256 a, uint256 b, uint256 t, uint256 begin, uint256 end)
internal
pure
returns (uint256)
{
if (begin > end) {
t = ~t;
begin = ~begin;
end = ~end;
}
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return a + fullMulDiv(b - a, t - begin, end - begin);
return a - fullMulDiv(a - b, t - begin, end - begin);
}
}
function lerp(int256 a, int256 b, int256 t, int256 begin, int256 end)
internal
pure
returns (int256)
{
if (begin > end) {
t = int256(~uint256(t));
begin = int256(~uint256(begin));
end = int256(~uint256(end));
}
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return int256(uint256(a) + fullMulDiv(uint256(b) - uint256(a),
uint256(t) - uint256(begin), uint256(end) - uint256(begin)));
return int256(uint256(a) - fullMulDiv(uint256(a) - uint256(b),
uint256(t) - uint256(begin), uint256(end) - uint256(begin)));
}
}
function rawAdd(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x + y;
}
}
function rawAdd(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x + y;
}
}
function rawSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x - y;
}
}
function rawSub(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x - y;
}
}
function rawMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x * y;
}
}
function rawMul(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x * y;
}
}
function rawDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(x, y)
}
}
function rawSDiv(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(x, y)
}
}
function rawMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mod(x, y)
}
}
function rawSMod(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := smod(x, y)
}
}
function rawAddMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := addmod(x, y, d)
}
}
function rawMulMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mulmod(x, y, d)
}
}
}
文件 10 的 33：IERC1155.sol
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(
address[] calldata accounts,
uint256[] calldata ids
) external view returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external;
}
文件 11 的 33：IERC1155MetadataURI.sol
pragma solidity ^0.8.20;
import {IERC1155} from "../IERC1155.sol";
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
文件 12 的 33：IERC1155Receiver.sol
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
文件 13 的 33：IERC165.sol
pragma solidity ^0.8.20;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 14 的 33：IERC20.sol
pragma solidity ^0.8.20;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
文件 15 的 33：IERC20Metadata.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 16 的 33：IERC20Permit.sol
pragma solidity ^0.8.20;
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);
}
文件 17 的 33：IERC5267.sol
pragma solidity ^0.8.20;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 18 的 33：ISilicaIndex.sol
pragma solidity ^0.8.0;
interface ISilicaIndex {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint256);
function shares() external view returns (uint256);
function balanceToken() external view returns (address);
function balance() external view returns (uint256);
}
文件 19 的 33：ISilicaPools.sol
pragma solidity ^0.8.0;
import {IERC20} from "@openzeppelin/token/ERC20/IERC20.sol";
import {IERC1155} from "@openzeppelin/token/ERC1155/IERC1155.sol";
import {ISilicaIndex} from "./ISilicaIndex.sol";
interface ISilicaPools is IERC1155 {
event SilicaPools__FillFeeChanged(uint256 newFeeBps);
event SilicaPools__GracePeriodChanged(uint256 newGracePeriod);
event SilicaPools__BountyIncreaseRateChanged(uint256 newRate);
event SilicaPools__MaxBountyFractionChanged(uint256 newMaxFraction);
event SilicaPools__TreasuryAddressChanged(address newTreasuryAddress);
event SilicaPools__PauseProtocol();
event SilicaPools__UnpauseProtocol();
event SilicaPools__OrderCancelled(bytes32 indexed orderHash);
event SilicaPools__PoolStarted(
bytes32 indexed poolHash,
uint128 floor,
uint128 cap,
uint48 targetStartTime,
uint48 targetEndTime,
address indexed index,
address indexed payoutToken,
uint128 indexShares,
uint128 indexInitialBalance
);
event SilicaPools__BountyPaid(bytes32 indexed poolHash, uint256 bountyAmount, address receiver);
event SilicaPools__PoolEnded(bytes32 indexed poolHash, uint256 endingIndexBalance, uint128 balanceChangePerShare);
event SilicaPools__CollateralizedMint(
bytes32 indexed poolHash,
bytes32 indexed orderHash,
address shortRecipient,
address longRecipient,
address indexed payer,
address payoutToken,
uint256 sharesMinted,
uint256 collateralAmount
);
event SilicaPools__FillFeePaid(
address indexed payer,
bytes32 indexed poolHash,
bytes32 indexed orderHash,
uint256 tokenId,
address tokenPaid,
uint256 amount
);
event SilicaPools__SharesRefunded(
bytes32 indexed poolHash,
address indexed recipient,
address indexed payoutToken,
uint256 sharesRefunded,
uint256 payoutTokenAmount
);
event SilicaPools__SharesRedeemed(
bytes32 indexed poolHash,
address indexed recipient,
address indexed payoutToken,
uint256 tokenId,
uint256 sharesRedeemed,
uint256 payoutTokenAmount
);
event SilicaPools__TradeHistoryEvent(
bytes32 indexed orderHash,
address indexed maker,
address indexed taker,
bytes32 offeredPoolHash,
bytes32 requestedPoolHash,
address offeredIndex,
address requestedIndex,
uint256 filledFraction,
uint256 remainingFraction
);
event SilicaPools__VolumeAccountingEvent(
bytes32 indexed orderHash,
bytes32 poolHash,
address indexed index,
address payoutToken,
uint256 capMinusFloor,
uint256 sharesMinted,
uint256 sharesTransferred,
address indexed upfrontTokenAddr,
uint256 upfrontTokenAmount
);
error SilicaPools__ArrayLengthMismatch();
error SilicaPools__InvalidSignature(bytes signature);
error SilicaPools__PoolAlreadyEnded(bytes32 poolHash);
error SilicaPools__PoolAlreadyStarted(bytes32 poolHash);
error SilicaPools__PoolNotEnded(bytes32 poolHash);
error SilicaPools__OrderIsCancelled(bytes32 orderHash);
error SilicaPools__PartialOrdersNotSupported(bytes32 orderHash);
error SilicaPools__OrderExpired(uint256 expiry, uint256 blockTimestamp);
error SilicaPools__InvalidCaller(address caller, address expectedCaller);
error SilicaPools__TooEarlyToStart(uint256 attemptedTimestamp, uint256 targetTimestamp);
error SilicaPools__TooEarlyToEnd(uint256 attemptedTimestamp, uint256 targetTimestamp);
error SilicaPools__Paused();
struct PoolParams {
uint128 floor;
uint128 cap;
address index;
uint48 targetStartTimestamp;
uint48 targetEndTimestamp;
address payoutToken;
}
struct PoolState {
uint128 collateralMinted;
uint128 sharesMinted;
uint128 indexShares;
uint128 indexInitialBalance;
uint48 actualStartTimestamp;
uint48 actualEndTimestamp;
uint128 balanceChangePerShare;
}
struct SilicaOrder {
address maker;
address taker;
uint48 expiry;
address offeredUpfrontToken;
uint128 offeredUpfrontAmount;
PoolParams offeredLongSharesParams;
uint128 offeredLongShares;
address requestedUpfrontToken;
uint128 requestedUpfrontAmount;
PoolParams requestedLongSharesParams;
uint128 requestedLongShares;
}
function domainSeparatorV4() external view returns (bytes32);
function fillFeeBps() external returns (uint256);
function setFillFeeBps(uint256 newFeeBps) external;
function treasuryAddress() external view returns (address);
function setTreasuryAddress(address newTreasury) external;
function bountyGracePeriod() external view returns (uint256);
function setBountyGracePeriod(uint256 newGracePeriod) external;
function maxBountyFraction() external view returns (uint256);
function setMaxBountyFraction(uint256 newMaxFraction) external;
function bountyFractionIncreasePerSecond() external view returns (uint256);
function setBountyFractionIncreasePerSecond(uint256 newIncreaseAmount) external;
function pause() external;
function unpause() external;
function poolState(bytes32 poolHash) external view returns (PoolState memory);
function orderCancelled(bytes32 orderHash) external view returns (bool);
function collateralizedMint(
PoolParams calldata poolParams,
bytes32 orderHash,
uint256 shares,
address longRecipient,
address shortRecipient
) external;
function collateralRefund(PoolParams[] calldata poolParams, uint256[] calldata shares) external;
function maxCollateralRefund(PoolParams[] calldata poolParams) external;
function fillOrders(SilicaOrder[] calldata orders, bytes[] calldata signatures, uint256[] calldata fractions)
external;
function cancelOrders(SilicaOrder[] calldata orders) external;
function startBounty(PoolParams[] calldata poolParams) external view returns (uint256[] memory);
function startPools(PoolParams[] calldata poolParams) external;
function endBounty(PoolParams[] calldata poolParams) external view returns (uint256[] memory);
function endPools(PoolParams[] calldata poolParams) external;
function redeem(PoolParams[] calldata longPoolParams, PoolParams[] calldata shortPoolParams) external;
function viewRedeemShort(PoolParams calldata shortParams, address account)
external
view
returns (uint256 expectedPayout);
function viewRedeemLong(PoolParams calldata longParams, address account)
external
view
returns (uint256 expectedPayout);
function viewCollateralRefund(PoolParams[] calldata poolParams, uint256[] calldata shares)
external
view
returns (uint256[] memory expectedRefunds);
function viewMaxCollateralRefund(PoolParams[] calldata poolparams, address[] calldata accounts)
external
view
returns (uint256[] memory expectedRefund);
}
文件 20 的 33：Math.sol
pragma solidity ^0.8.20;
library Math {
error MathOverflowedMulDiv();
enum Rounding {
Floor,
Ceil,
Trunc,
Expand
}
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);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
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 average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
return a / b;
}
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0 = x * y;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (0 - denominator);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
文件 21 的 33：MessageHashUtils.sol
pragma solidity ^0.8.20;
import {Strings} from "../Strings.sol";
library MessageHashUtils {
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, messageHash)
digest := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}
文件 22 的 33：Ownable.sol
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
error OwnableUnauthorizedAccount(address account);
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 23 的 33：Ownable2Step.sol
pragma solidity ^0.8.20;
import {Ownable} from "./Ownable.sol";
abstract contract Ownable2Step is Ownable {
address private _pendingOwner;
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
function _transferOwnership(address newOwner) internal virtual override {
delete _pendingOwner;
super._transferOwnership(newOwner);
}
function acceptOwnership() public virtual {
address sender = _msgSender();
if (pendingOwner() != sender) {
revert OwnableUnauthorizedAccount(sender);
}
_transferOwnership(sender);
}
}
文件 24 的 33：PoolMaths.sol
pragma solidity ^0.8.0;
import {ISilicaPools} from "../interfaces/ISilicaPools.sol";
import {FixedPointMathLib} from "solady/utils/FixedPointMathLib.sol";
library PoolMaths {
function collateral(bool isRoundUp, uint128 floor, uint128 cap, uint256 shares, uint256 shareDecimals)
internal
pure
returns (uint256)
{
uint256 intermediateValue = (cap - floor) * shares;
return isRoundUp
? FixedPointMathLib.divUp(intermediateValue, 10 ** shareDecimals)
: intermediateValue / 10 ** shareDecimals;
}
function shortPayout(
ISilicaPools.PoolParams memory shortParams,
ISilicaPools.PoolState memory sState,
uint256 shortSharesBalance
) internal pure returns (uint256 payout) {
payout = (
(
(uint256(shortParams.cap - sState.balanceChangePerShare) * uint256(sState.collateralMinted))
/ uint256(shortParams.cap - shortParams.floor)
) * uint256(shortSharesBalance)
) / uint256(sState.sharesMinted);
}
function longPayout(
ISilicaPools.PoolParams calldata longParams,
ISilicaPools.PoolState memory sState,
uint256 longSharesBalance
) internal pure returns (uint256 payout) {
payout = (
(
(uint256(sState.balanceChangePerShare - longParams.floor) * uint256(sState.collateralMinted))
/ uint256(longParams.cap - longParams.floor)
) * uint256(longSharesBalance)
) / uint256(sState.sharesMinted);
}
function grossBalanceChangePerShare(
uint256 indexBalance,
uint256 indexInitialBalance,
uint256 indexShares,
uint256 indexDecimals
) internal pure returns (uint256) {
require(indexShares > 0, "Index shares must be greater than zero");
require(
indexBalance >= indexInitialBalance, "Index balance must be greater than or equal to the initial balance"
);
return ((indexBalance - indexInitialBalance) * 10 ** indexDecimals) / indexShares;
}
function _balanceChangePerShare(uint256 floor, uint256 cap, uint256 grossBalanceChangePerShare)
internal
pure
returns (uint256)
{
return max(floor, min(cap, grossBalanceChangePerShare));
}
function balanceChangePerShare(
uint256 indexBalance,
uint128 indexInitialBalance,
uint128 indexShares,
uint256 indexDecimals,
uint128 floor,
uint128 cap
) internal pure returns (uint256) {
return _balanceChangePerShare(
floor, cap, grossBalanceChangePerShare(indexBalance, indexInitialBalance, indexShares, indexDecimals)
);
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
}
文件 25 的 33：ReentrancyGuard.sol
pragma solidity ^0.8.20;
abstract contract ReentrancyGuard {
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status;
error ReentrancyGuardReentrantCall();
constructor() {
_status = NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
_status = ENTERED;
}
function _nonReentrantAfter() private {
_status = NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}
文件 26 的 33：SafeCast.sol
pragma solidity ^0.8.20;
library SafeCast {
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
error SafeCastOverflowedIntToUint(int256 value);
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
error SafeCastOverflowedUintToInt(uint256 value);
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
function toInt256(uint256 value) internal pure returns (int256) {
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
}
文件 27 的 33：SafeERC20.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
error SafeERC20FailedOperation(address token);
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}
文件 28 的 33：ShortStrings.sol
pragma solidity ^0.8.20;
import {StorageSlot} from "./StorageSlot.sol";
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
文件 29 的 33：SignedMath.sol
pragma solidity ^0.8.20;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 30 的 33：SilicaPools.sol
pragma solidity ^0.8.0;
import {Ownable} from "@openzeppelin/access/Ownable.sol";
import {ERC20} from "@openzeppelin/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/token/ERC20/IERC20.sol";
import {SafeCast} from "@openzeppelin/utils/math/SafeCast.sol";
import {ERC1155} from "@openzeppelin/token/ERC1155/ERC1155.sol";
import {ECDSA} from "@openzeppelin/utils/cryptography/ECDSA.sol";
import {EIP712} from "@openzeppelin/utils/cryptography/EIP712.sol";
import {Ownable2Step} from "@openzeppelin/access/Ownable2Step.sol";
import {ReentrancyGuard} from "@openzeppelin/utils/ReentrancyGuard.sol";
import {SafeERC20} from "@openzeppelin/token/ERC20/utils/SafeERC20.sol";
import {MessageHashUtils} from "@openzeppelin/utils/cryptography/MessageHashUtils.sol";
import {PoolMaths} from "../libraries/PoolMaths.sol";
import {ISilicaPools} from "../interfaces/ISilicaPools.sol";
import {ISilicaIndex} from "../interfaces/ISilicaIndex.sol";
contract SilicaPools is ISilicaPools, ERC1155, EIP712, Ownable2Step, ReentrancyGuard {
using SafeCast for uint256;
using SafeCast for uint128;
using SafeERC20 for IERC20;
bytes32 constant SILICA_POOL_TYPEHASH = keccak256(
"PoolParams(uint128 floor,uint128 cap,address index,uint48 targetStartTimestamp,uint48 targetEndTimestamp,address payoutToken)"
);
bytes32 constant SILICA_ORDER_TYPEHASH = keccak256(
"SilicaOrder(address maker,address taker,uint48 expiry,address offeredUpfrontToken,uint128 offeredUpfrontAmount,uint128 offeredLongShares,PoolParams offeredLongSharesParams,address requestedUpfrontToken,uint128 requestedUpfrontAmount,uint128 requestedLongShares,PoolParams requestedLongSharesParams)PoolParams(uint128 floor,uint128 cap,address index,uint48 targetStartTimestamp,uint48 targetEndTimestamp,address payoutToken)"
);
bytes32 public constant TOKENID_SALT = bytes32(uint256(0xAC1D));
uint256 public constant INVERSE_BASIS_POINT = 10_000;
uint256 private sFillFeeBps;
uint256 public constant MAX_FILL_FEE_BPS = 1000;
address private sAlkimiyaTreasury;
mapping(bytes32 poolHash => PoolState state) private sPoolState;
mapping(bytes32 orderHash => bool isCancelled) private sOrderCancelled;
mapping(bytes32 orderHash => uint256 fraction) private sFilledFraction;
uint256 public sBountyGracePeriod;
uint256 public sMaxBountyFraction;
uint256 public sBountyFractionIncreasePerSecond;
bool public paused;
constructor(
uint256 startFeeBps,
address initialOwner,
address alkimiyaTreasury,
uint256 gracePeriod,
uint256 maxBountyFrac,
uint256 bountyIncreasePerSecond
) ERC1155("") Ownable(initialOwner) EIP712("SilicaPools", "1") {
assert(alkimiyaTreasury != address(0));
sAlkimiyaTreasury = alkimiyaTreasury;
assert(startFeeBps <= MAX_FILL_FEE_BPS);
sFillFeeBps = startFeeBps;
sBountyGracePeriod = gracePeriod;
sMaxBountyFraction = maxBountyFrac;
sBountyFractionIncreasePerSecond = bountyIncreasePerSecond;
emit SilicaPools__FillFeeChanged(startFeeBps);
emit SilicaPools__GracePeriodChanged(sBountyGracePeriod);
emit SilicaPools__TreasuryAddressChanged(alkimiyaTreasury);
emit SilicaPools__MaxBountyFractionChanged(sMaxBountyFraction);
emit SilicaPools__BountyIncreaseRateChanged(sBountyFractionIncreasePerSecond);
}
function setFillFeeBps(uint256 newFillFeeBps) external onlyOwner {
if (newFillFeeBps > MAX_FILL_FEE_BPS) {
revert("Cannot exceed max fee BPS");
}
sFillFeeBps = newFillFeeBps;
emit SilicaPools__FillFeeChanged(newFillFeeBps);
}
function setTreasuryAddress(address newTreasury) external onlyOwner {
assert(newTreasury != address(0));
sAlkimiyaTreasury = newTreasury;
emit SilicaPools__TreasuryAddressChanged(newTreasury);
}
function setBountyGracePeriod(uint256 newGracePeriod) external onlyOwner {
sBountyGracePeriod = newGracePeriod;
emit SilicaPools__GracePeriodChanged(sBountyGracePeriod);
}
function setMaxBountyFraction(uint256 newMaxFraction) external onlyOwner {
sMaxBountyFraction = newMaxFraction;
emit SilicaPools__MaxBountyFractionChanged(sMaxBountyFraction);
}
function setBountyFractionIncreasePerSecond(uint256 newIncreaseAmount) external onlyOwner {
sBountyFractionIncreasePerSecond = newIncreaseAmount;
emit SilicaPools__BountyIncreaseRateChanged(sBountyFractionIncreasePerSecond);
}
function pause() external onlyOwner {
paused = true;
emit SilicaPools__PauseProtocol();
}
function unpause() external onlyOwner {
paused = false;
emit SilicaPools__UnpauseProtocol();
}
function startPools(PoolParams[] calldata poolParams) external {
for (uint256 i = 0; i < poolParams.length; ++i) {
startPool(poolParams[i]);
}
}
function collateralizedMint(
PoolParams calldata poolParams,
bytes32 orderHash,
uint256 shares,
address longRecipient,
address shortRecipient
) external {
_collateralizedMint(poolParams, orderHash, shares, msg.sender, longRecipient, shortRecipient);
}
function maxCollateralRefund(PoolParams[] calldata poolParams) external nonReentrant {
for (uint256 i; i < poolParams.length; ++i) {
bytes32 poolHash = hashPool(poolParams[i]);
uint256 longBalance = balanceOf(msg.sender, toLongTokenId(poolHash));
uint256 shortBalance = balanceOf(msg.sender, toShortTokenId(poolHash));
_collateralRefund(poolParams[i], longBalance < shortBalance ? longBalance : shortBalance);
}
}
function cancelOrders(SilicaOrder[] calldata orders) external {
for (uint256 i = 0; i < orders.length; ++i) {
SilicaOrder calldata order = orders[i];
if (order.maker != msg.sender) {
revert SilicaPools__InvalidCaller(msg.sender, order.maker);
}
bytes32 orderHash = hashOrder(order, _domainSeparatorV4());
sOrderCancelled[orderHash] = true;
emit SilicaPools__OrderCancelled(orderHash);
}
}
function fillOrders(SilicaOrder[] calldata orders, bytes[] calldata signatures, uint256[] calldata fractions)
external
{
if (orders.length != signatures.length || orders.length != fractions.length) {
revert SilicaPools__ArrayLengthMismatch();
}
for (uint256 i = 0; i < orders.length; ++i) {
fillOrder(orders[i], signatures[i], fractions[i]);
}
}
function endPools(PoolParams[] calldata poolParams) external {
for (uint256 i = 0; i < poolParams.length; ++i) {
endPool(poolParams[i]);
}
}
function redeem(PoolParams[] calldata longPoolParams, PoolParams[] calldata shortPoolParams) external {
for (uint256 i = 0; i < longPoolParams.length; ++i) {
redeemLong(longPoolParams[i]);
}
for (uint256 i = 0; i < shortPoolParams.length; ++i) {
redeemShort(shortPoolParams[i]);
}
}
function poolState(bytes32 poolHash) external view returns (PoolState memory) {
return sPoolState[poolHash];
}
function startBounty(PoolParams[] calldata poolParams) external view returns (uint256[] memory) {
uint256[] memory bounties = new uint256[](poolParams.length);
for (uint256 i = 0; i < poolParams.length; ++i) {
bounties[i] = _startBounty(poolParams[i]);
}
return bounties;
}
function endBounty(PoolParams[] calldata poolParams) external view returns (uint256[] memory) {
uint256[] memory bounties = new uint256[](poolParams.length);
for (uint256 i = 0; i < poolParams.length; ++i) {
bounties[i] = _endBounty(poolParams[i]);
}
return bounties;
}
function viewRedeemShort(PoolParams calldata shortParams, address account)
external
view
returns (uint256 expectedPayout)
{
bytes32 poolHash = hashPool(shortParams);
PoolState storage sState = sPoolState[poolHash];
if (sState.actualEndTimestamp == 0) {
revert SilicaPools__PoolNotEnded(poolHash);
}
uint256 shortTokenId = toShortTokenId(poolHash);
uint256 shortSharesBalance = balanceOf(account, shortTokenId);
expectedPayout = PoolMaths.shortPayout(shortParams, sState, shortSharesBalance);
}
function viewRedeemLong(PoolParams calldata longParams, address account)
external
view
returns (uint256 expectedPayout)
{
bytes32 poolHash = hashPool(longParams);
PoolState storage sState = sPoolState[poolHash];
if (sState.actualEndTimestamp == 0) {
revert SilicaPools__PoolNotEnded(poolHash);
}
uint256 longTokenId = toLongTokenId(poolHash);
uint256 longSharesBalance = balanceOf(account, longTokenId);
expectedPayout = PoolMaths.longPayout(longParams, sState, longSharesBalance);
}
function viewCollateralRefund(PoolParams[] calldata poolParams, uint256[] calldata shares)
external
view
returns (uint256[] memory expectedRefunds)
{
if (poolParams.length != shares.length) {
revert SilicaPools__ArrayLengthMismatch();
}
expectedRefunds = new uint256[](poolParams.length);
for (uint256 i; i < poolParams.length; ++i) {
bytes32 poolHash = hashPool(poolParams[i]);
ISilicaPools.PoolState storage sState = sPoolState[poolHash];
uint256 refundCollateral = (uint256(sState.collateralMinted) * shares[i]) / uint256(sState.sharesMinted);
expectedRefunds[i] = refundCollateral;
}
}
function viewMaxCollateralRefund(PoolParams[] calldata poolParams, address[] calldata accounts)
external
view
returns (uint256[] memory expectedRefund)
{
if (poolParams.length != accounts.length) {
revert SilicaPools__ArrayLengthMismatch();
}
expectedRefund = new uint256[](poolParams.length);
for (uint256 i; i < poolParams.length; ++i) {
bytes32 poolHash = hashPool(poolParams[i]);
uint256 longBalance = balanceOf(msg.sender, toLongTokenId(poolHash));
uint256 shortBalance = balanceOf(msg.sender, toShortTokenId(poolHash));
ISilicaPools.PoolState storage sState = sPoolState[poolHash];
if (longBalance < shortBalance) {
expectedRefund[i] = (uint256(sState.collateralMinted) * longBalance) / uint256(sState.sharesMinted);
} else {
expectedRefund[i] = (uint256(sState.collateralMinted) * shortBalance) / uint256(sState.sharesMinted);
}
}
}
function fillFeeBps() external view returns (uint256) {
return sFillFeeBps;
}
function treasuryAddress() external view returns (address) {
return sAlkimiyaTreasury;
}
function bountyGracePeriod() external view returns (uint256) {
return sBountyGracePeriod;
}
function maxBountyFraction() external view returns (uint256) {
return sMaxBountyFraction;
}
function bountyFractionIncreasePerSecond() external view returns (uint256) {
return sBountyFractionIncreasePerSecond;
}
function domainSeparatorV4() external view returns (bytes32) {
return _domainSeparatorV4();
}
function orderCancelled(bytes32 orderHash) external view returns (bool) {
return sOrderCancelled[orderHash];
}
function startPool(PoolParams calldata poolParams) public {
bytes32 poolHash = hashPool(poolParams);
PoolState storage sState = sPoolState[poolHash];
ISilicaIndex index = ISilicaIndex(poolParams.index);
if (block.timestamp < poolParams.targetStartTimestamp) {
revert SilicaPools__TooEarlyToStart(block.timestamp, poolParams.targetStartTimestamp);
}
if (sState.actualStartTimestamp != 0) {
revert SilicaPools__PoolAlreadyStarted(poolHash);
}
sState.actualStartTimestamp = uint48(block.timestamp);
sState.indexShares = uint128(index.shares());
sState.indexInitialBalance = uint128(index.balance());
uint256 startBountyAmount = _startBounty(poolParams);
sState.collateralMinted -= uint128(startBountyAmount);
SafeERC20.safeTransfer(IERC20(poolParams.payoutToken), msg.sender, startBountyAmount);
emit SilicaPools__BountyPaid(poolHash, startBountyAmount, msg.sender);
emit SilicaPools__PoolStarted(
poolHash,
poolParams.floor,
poolParams.cap,
poolParams.targetStartTimestamp,
poolParams.targetEndTimestamp,
address(index),
poolParams.payoutToken,
sState.indexShares,
sState.indexInitialBalance
);
}
function endPool(PoolParams calldata poolParams) public {
bytes32 poolHash = hashPool(poolParams);
PoolState storage sState = sPoolState[poolHash];
ISilicaIndex index = ISilicaIndex(poolParams.index);
if (sState.actualEndTimestamp != 0) {
revert SilicaPools__PoolAlreadyEnded(poolHash);
}
if (block.timestamp < poolParams.targetEndTimestamp) {
revert SilicaPools__TooEarlyToEnd(block.timestamp, poolParams.targetEndTimestamp);
}
uint256 indexBalanceAtEnd = index.balance();
sState.balanceChangePerShare = uint128(
PoolMaths.balanceChangePerShare(
indexBalanceAtEnd,
sState.indexInitialBalance,
sState.indexShares,
index.decimals(),
poolParams.floor,
poolParams.cap
)
);
sState.actualEndTimestamp = uint48(block.timestamp);
uint256 endBountyAmount = _endBounty(poolParams);
sState.collateralMinted -= uint128(endBountyAmount);
SafeERC20.safeTransfer(IERC20(poolParams.payoutToken), msg.sender, endBountyAmount);
emit SilicaPools__BountyPaid(poolHash, endBountyAmount, msg.sender);
emit SilicaPools__PoolEnded(poolHash, indexBalanceAtEnd, sState.balanceChangePerShare);
}
function fillOrder(SilicaOrder calldata order, bytes calldata signature, uint256 fraction) public nonReentrant {
if (paused) {
revert SilicaPools__Paused();
}
bytes32 orderHash = hashOrder(order, _domainSeparatorV4());
if (fraction != 1e18) {
revert SilicaPools__PartialOrdersNotSupported(orderHash);
}
if (sOrderCancelled[orderHash]) {
revert SilicaPools__OrderIsCancelled(orderHash);
}
if (ECDSA.recover(orderHash, signature) != order.maker) {
revert SilicaPools__InvalidSignature(signature);
}
if (order.taker != address(0) && order.taker != msg.sender) {
revert SilicaPools__InvalidCaller(msg.sender, order.taker);
}
if (order.expiry < block.timestamp) {
revert SilicaPools__OrderExpired(order.expiry, block.timestamp);
}
if (sPoolState[hashPool(order.offeredLongSharesParams)].actualEndTimestamp != 0) {
revert SilicaPools__PoolAlreadyEnded(hashPool(order.offeredLongSharesParams));
}
if (sPoolState[hashPool(order.requestedLongSharesParams)].actualEndTimestamp != 0) {
revert SilicaPools__PoolAlreadyEnded(hashPool(order.requestedLongSharesParams));
}
if (order.offeredUpfrontAmount != 0) {
SafeERC20.safeTransferFrom(
IERC20(order.offeredUpfrontToken),
order.maker,
msg.sender,
(uint256(order.offeredUpfrontAmount) * fraction) / 1e18
);
}
if (order.requestedUpfrontAmount != 0) {
SafeERC20.safeTransferFrom(
IERC20(order.requestedUpfrontToken),
msg.sender,
order.maker,
(uint256(order.requestedUpfrontAmount) * fraction) / 1e18
);
}
if (order.offeredLongShares != 0) {
uint256 indexDecimals = ISilicaIndex(order.offeredLongSharesParams.index).decimals();
uint256 collateral = PoolMaths.collateral(
true,
order.offeredLongSharesParams.floor,
order.offeredLongSharesParams.cap,
(uint256(order.offeredLongShares) * fraction) / 1e18,
indexDecimals
);
uint256 surcharge = (collateral * sFillFeeBps) / INVERSE_BASIS_POINT;
SafeERC20.safeTransferFrom(
IERC20(order.offeredLongSharesParams.payoutToken), msg.sender, sAlkimiyaTreasury, surcharge
);
uint256 tokenId = toShortTokenId(hashPool(order.offeredLongSharesParams));
emit SilicaPools__FillFeePaid(
msg.sender,
hashPool(order.offeredLongSharesParams),
orderHash,
tokenId,
order.offeredLongSharesParams.payoutToken,
surcharge
);
_collateralizedMint(
order.offeredLongSharesParams,
orderHash,
(uint256(order.offeredLongShares) * fraction) / 1e18,
order.maker,
msg.sender,
order.maker
);
}
if (order.requestedLongShares != 0) {
uint256 indexDecimals = ISilicaIndex(order.requestedLongSharesParams.index).decimals();
uint256 collateral = PoolMaths.collateral(
true,
order.requestedLongSharesParams.floor,
order.requestedLongSharesParams.cap,
(uint256(order.requestedLongShares) * fraction) / 1e18,
indexDecimals
);
uint256 surcharge = (collateral * sFillFeeBps) / INVERSE_BASIS_POINT;
SafeERC20.safeTransferFrom(
IERC20(order.requestedLongSharesParams.payoutToken), msg.sender, sAlkimiyaTreasury, surcharge
);
uint256 tokenId = toLongTokenId(hashPool(order.requestedLongSharesParams));
emit SilicaPools__FillFeePaid(
msg.sender,
hashPool(order.requestedLongSharesParams),
orderHash,
tokenId,
order.requestedLongSharesParams.payoutToken,
surcharge
);
_collateralizedMint(
order.requestedLongSharesParams,
orderHash,
(uint256(order.requestedLongShares) * fraction) / 1e18,
msg.sender,
order.maker,
msg.sender
);
}
{
uint256 newFilledFraction = sFilledFraction[orderHash] + fraction;
sFilledFraction[orderHash] = newFilledFraction;
emit SilicaPools__TradeHistoryEvent(
orderHash,
order.maker,
msg.sender,
hashPool(order.offeredLongSharesParams),
hashPool(order.requestedLongSharesParams),
order.offeredLongSharesParams.index,
order.requestedLongSharesParams.index,
fraction,
1e18 - newFilledFraction
);
}
if (order.offeredLongShares > 0 || order.requestedUpfrontAmount > 0) {
emit SilicaPools__VolumeAccountingEvent(
orderHash,
hashPool(order.offeredLongSharesParams),
order.offeredLongSharesParams.index,
order.offeredLongSharesParams.payoutToken,
order.offeredLongSharesParams.cap - order.offeredLongSharesParams.floor,
(order.offeredLongShares * fraction) / 1e18,
(order.offeredLongShares * fraction) / 1e18,
order.requestedUpfrontToken,
(order.requestedUpfrontAmount * fraction) / 1e18
);
}
if (order.requestedLongShares > 0 || order.offeredUpfrontAmount > 0) {
emit SilicaPools__VolumeAccountingEvent(
orderHash,
hashPool(order.requestedLongSharesParams),
order.requestedLongSharesParams.index,
order.requestedLongSharesParams.payoutToken,
order.requestedLongSharesParams.cap - order.requestedLongSharesParams.floor,
(order.requestedLongShares * fraction) / 1e18,
(order.requestedLongShares * fraction) / 1e18,
order.offeredUpfrontToken,
(order.offeredUpfrontAmount * fraction) / 1e18
);
}
}
function redeemLong(PoolParams calldata longParams) public {
bytes32 poolHash = hashPool(longParams);
PoolState storage sState = sPoolState[poolHash];
if (sState.actualEndTimestamp == 0) {
revert SilicaPools__PoolNotEnded(poolHash);
}
uint256 longTokenId = toLongTokenId(poolHash);
uint256 longSharesBalance = balanceOf(msg.sender, longTokenId);
uint256 payout = PoolMaths.longPayout(longParams, sState, longSharesBalance);
_burn(msg.sender, longTokenId, longSharesBalance);
SafeERC20.safeTransfer(IERC20(longParams.payoutToken), msg.sender, payout);
emit SilicaPools__SharesRedeemed(
poolHash, msg.sender, longParams.payoutToken, longTokenId, longSharesBalance, payout
);
}
function redeemShort(PoolParams calldata shortParams) public {
bytes32 poolHash = hashPool(shortParams);
PoolState storage sState = sPoolState[poolHash];
if (sState.actualEndTimestamp == 0) {
revert SilicaPools__PoolNotEnded(poolHash);
}
uint256 shortTokenId = toShortTokenId(poolHash);
uint256 shortSharesBalance = balanceOf(msg.sender, shortTokenId);
uint256 payout = PoolMaths.shortPayout(shortParams, sState, shortSharesBalance);
_burn(msg.sender, shortTokenId, shortSharesBalance);
SafeERC20.safeTransfer(IERC20(shortParams.payoutToken), msg.sender, payout);
emit SilicaPools__SharesRedeemed(
poolHash, msg.sender, shortParams.payoutToken, shortTokenId, shortSharesBalance, payout
);
}
function collateralRefund(PoolParams[] calldata poolParams, uint256[] calldata shares) public nonReentrant {
if (poolParams.length != shares.length) {
revert SilicaPools__ArrayLengthMismatch();
}
for (uint256 i; i < poolParams.length; ++i) {
_collateralRefund(poolParams[i], shares[i]);
}
}
function toLongTokenId(bytes32 poolHash) public pure returns (uint256) {
return uint256(poolHash);
}
function toShortTokenId(bytes32 poolHash) public pure returns (uint256) {
return uint256(poolHash ^ TOKENID_SALT);
}
function fromLongTokenId(uint256 longTokenId) public pure returns (bytes32) {
return bytes32(longTokenId);
}
function fromShortTokenId(uint256 shortTokenId) public pure returns (bytes32) {
return bytes32(shortTokenId) ^ TOKENID_SALT;
}
function hashPool(PoolParams calldata poolParams) public pure returns (bytes32) {
return keccak256(
abi.encodePacked(
poolParams.floor,
poolParams.cap,
poolParams.index,
poolParams.targetStartTimestamp,
poolParams.targetEndTimestamp,
poolParams.payoutToken
)
);
}
function hashOrder(SilicaOrder calldata order, bytes32 domainSeparator) public pure returns (bytes32) {
bytes32 offeredStructHash = keccak256(abi.encode(SILICA_POOL_TYPEHASH, order.offeredLongSharesParams));
bytes32 requestedStructHash = keccak256(abi.encode(SILICA_POOL_TYPEHASH, order.requestedLongSharesParams));
bytes32 structHash = keccak256(
abi.encode(
SILICA_ORDER_TYPEHASH,
order.maker,
order.taker,
order.expiry,
order.offeredUpfrontToken,
order.offeredUpfrontAmount,
order.offeredLongShares,
offeredStructHash,
order.requestedUpfrontToken,
order.requestedUpfrontAmount,
order.requestedLongShares,
requestedStructHash
)
);
return MessageHashUtils.toTypedDataHash(domainSeparator, structHash);
}
function _collateralizedMint(
PoolParams calldata poolParams,
bytes32 orderHash,
uint256 shares,
address payer,
address longRecipient,
address shortRecipient
) internal {
bytes32 poolHash = hashPool(poolParams);
if (sPoolState[poolHash].actualEndTimestamp != 0) {
revert SilicaPools__PoolAlreadyEnded(poolHash);
}
ISilicaIndex index = ISilicaIndex(poolParams.index);
ISilicaPools.PoolState storage sState = sPoolState[poolHash];
uint256 collateral = PoolMaths.collateral(true, poolParams.floor, poolParams.cap, shares, index.decimals());
sState.collateralMinted += uint128(collateral);
SafeERC20.safeTransferFrom(IERC20(poolParams.payoutToken), payer, address(this), collateral);
if (longRecipient == address(0)) {
longRecipient = msg.sender;
}
if (shortRecipient == address(0)) {
shortRecipient = msg.sender;
}
sState.sharesMinted += uint128(shares);
_mint(longRecipient, toLongTokenId(poolHash), shares, "");
_mint(shortRecipient, toShortTokenId(poolHash), shares, "");
emit SilicaPools__CollateralizedMint(
poolHash, orderHash, shortRecipient, longRecipient, payer, poolParams.payoutToken, shares, collateral
);
}
function _startBounty(PoolParams calldata poolParams) internal view returns (uint256 bounty) {
bytes32 poolHash = hashPool(poolParams);
ISilicaPools.PoolState storage sState = sPoolState[poolHash];
uint256 collateral = sState.collateralMinted;
uint256 uncappedBountyFraction = block.timestamp > poolParams.targetStartTimestamp + sBountyGracePeriod
? uint256(block.timestamp - poolParams.targetStartTimestamp - sBountyGracePeriod)
* sBountyFractionIncreasePerSecond
: 0;
uint256 bountyFraction =
uncappedBountyFraction > sMaxBountyFraction ? sMaxBountyFraction : uncappedBountyFraction;
bounty = (bountyFraction * collateral) / 1e18;
}
function _endBounty(PoolParams calldata poolParams) internal view returns (uint256 bounty) {
bytes32 poolHash = hashPool(poolParams);
uint256 collateral = sPoolState[poolHash].collateralMinted;
uint256 uncappedBountyFraction = block.timestamp > poolParams.targetEndTimestamp + sBountyGracePeriod
? uint256(block.timestamp - poolParams.targetEndTimestamp - sBountyGracePeriod)
* sBountyFractionIncreasePerSecond
: 0;
uint256 bountyFraction =
uncappedBountyFraction > sMaxBountyFraction ? sMaxBountyFraction : uncappedBountyFraction;
bounty = (bountyFraction * collateral) / 1e18;
}
function _collateralRefund(PoolParams calldata poolParams, uint256 shares) internal {
bytes32 poolHash = hashPool(poolParams);
ISilicaPools.PoolState storage sState = sPoolState[poolHash];
uint256 refundCollateral = (uint256(sState.collateralMinted) * shares) / uint256(sState.sharesMinted);
sState.sharesMinted -= uint128(shares);
_burn(msg.sender, toLongTokenId(poolHash), shares);
_burn(msg.sender, toShortTokenId(poolHash), shares);
sState.collateralMinted -= uint128(refundCollateral);
SafeERC20.safeTransfer(IERC20(poolParams.payoutToken), msg.sender, refundCollateral);
emit SilicaPools__SharesRefunded(poolHash, msg.sender, poolParams.payoutToken, shares, refundCollateral);
}
}
文件 31 的 33：StorageSlot.sol
pragma solidity ^0.8.20;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
文件 32 的 33：Strings.sol
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
error StringsInsufficientHexLength(uint256 value, uint256 length);
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 33 的 33：draft-IERC6093.sol
pragma solidity ^0.8.20;
interface IERC20Errors {
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
error ERC20InvalidSender(address sender);
error ERC20InvalidReceiver(address receiver);
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
error ERC20InvalidApprover(address approver);
error ERC20InvalidSpender(address spender);
}
interface IERC721Errors {
error ERC721InvalidOwner(address owner);
error ERC721NonexistentToken(uint256 tokenId);
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
error ERC721InvalidSender(address sender);
error ERC721InvalidReceiver(address receiver);
error ERC721InsufficientApproval(address operator, uint256 tokenId);
error ERC721InvalidApprover(address approver);
error ERC721InvalidOperator(address operator);
}
interface IERC1155Errors {
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
error ERC1155InvalidSender(address sender);
error ERC1155InvalidReceiver(address receiver);
error ERC1155MissingApprovalForAll(address operator, address owner);
error ERC1155InvalidApprover(address approver);
error ERC1155InvalidOperator(address operator);
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
{
"compilationTarget": {
"contracts/SilicaPools.sol": "SilicaPools"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [
":@openzeppelin/=lib/openzeppelin-contracts/contracts/",
":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":solady/=lib/solady/src/"
],
"viaIR": true
}[{"inputs":[{"internalType":"uint256","name":"startFeeBps","type":"uint256"},{"internalType":"address","name":"initialOwner","type":"address"},{"internalType":"address","name":"alkimiyaTreasury","type":"address"},{"internalType":"uint256","name":"gracePeriod","type":"uint256"},{"internalType":"uint256","name":"maxBountyFrac","type":"uint256"},{"internalType":"uint256","name":"bountyIncreasePerSecond","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155MissingApprovalForAll","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"SilicaPools__ArrayLengthMismatch","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"address","name":"expectedCaller","type":"address"}],"name":"SilicaPools__InvalidCaller","type":"error"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"SilicaPools__InvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint256","name":"blockTimestamp","type":"uint256"}],"name":"SilicaPools__OrderExpired","type":"error"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"SilicaPools__OrderIsCancelled","type":"error"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"SilicaPools__PartialOrdersNotSupported","type":"error"},{"inputs":[],"name":"SilicaPools__Paused","type":"error"},{"inputs":[{"internalType":"bytes32","name":"poolHash","type":"bytes32"}],"name":"SilicaPools__PoolAlreadyEnded","type":"error"},{"inputs":[{"internalType":"bytes32","name":"poolHash","type":"bytes32"}],"name":"SilicaPools__PoolAlreadyStarted","type":"error"},{"inputs":[{"internalType":"bytes32","name":"poolHash","type":"bytes32"}],"name":"SilicaPools__PoolNotEnded","type":"error"},{"inputs":[{"internalType":"uint256","name":"attemptedTimestamp","type":"uint256"},{"internalType":"uint256","name":"targetTimestamp","type":"uint256"}],"name":"SilicaPools__TooEarlyToEnd","type":"error"},{"inputs":[{"internalType":"uint256","name":"attemptedTimestamp","type":"uint256"},{"internalType":"uint256","name":"targetTimestamp","type":"uint256"}],"name":"SilicaPools__TooEarlyToStart","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newRate","type":"uint256"}],"name":"SilicaPools__BountyIncreaseRateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"bountyAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"receiver","type":"address"}],"name":"SilicaPools__BountyPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolHash","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"indexed":false,"internalType":"address","name":"shortRecipient","type":"address"},{"indexed":false,"internalType":"address","name":"longRecipient","type":"address"},{"indexed":true,"internalType":"address","name":"payer","type":"address"},{"indexed":false,"internalType":"address","name":"payoutToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"sharesMinted","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"collateralAmount","type":"uint256"}],"name":"SilicaPools__CollateralizedMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newFeeBps","type":"uint256"}],"name":"SilicaPools__FillFeeChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"payer","type":"address"},{"indexed":true,"internalType":"bytes32","name":"poolHash","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"tokenPaid","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SilicaPools__FillFeePaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newGracePeriod","type":"uint256"}],"name":"SilicaPools__GracePeriodChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMaxFraction","type":"uint256"}],"name":"SilicaPools__MaxBountyFractionChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"SilicaPools__OrderCancelled","type":"event"},{"anonymous":false,"inputs":[],"name":"SilicaPools__PauseProtocol","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"endingIndexBalance","type":"uint256"},{"indexed":false,"internalType":"uint128","name":"balanceChangePerShare","type":"uint128"}],"name":"SilicaPools__PoolEnded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolHash","type":"bytes32"},{"indexed":false,"internalType":"uint128","name":"floor","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"cap","type":"uint128"},{"indexed":false,"internalType":"uint48","name":"targetStartTime","type":"uint48"},{"indexed":false,"internalType":"uint48","name":"targetEndTime","type":"uint48"},{"indexed":true,"internalType":"address","name":"index","type":"address"},{"indexed":true,"internalType":"address","name":"payoutToken","type":"address"},{"indexed":false,"internalType":"uint128","name":"indexShares","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"indexInitialBalance","type":"uint128"}],"name":"SilicaPools__PoolStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"address","name":"payoutToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sharesRedeemed","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"payoutTokenAmount","type":"uint256"}],"name":"SilicaPools__SharesRedeemed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"address","name":"payoutToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"sharesRefunded","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"payoutTokenAmount","type":"uint256"}],"name":"SilicaPools__SharesRefunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"maker","type":"address"},{"indexed":true,"internalType":"address","name":"taker","type":"address"},{"indexed":false,"internalType":"bytes32","name":"offeredPoolHash","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"requestedPoolHash","type":"bytes32"},{"indexed":false,"internalType":"address","name":"offeredIndex","type":"address"},{"indexed":false,"internalType":"address","name":"requestedIndex","type":"address"},{"indexed":false,"internalType":"uint256","name":"filledFraction","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"remainingFraction","type":"uint256"}],"name":"SilicaPools__TradeHistoryEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newTreasuryAddress","type":"address"}],"name":"SilicaPools__TreasuryAddressChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"SilicaPools__UnpauseProtocol","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"poolHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"index","type":"address"},{"indexed":false,"internalType":"address","name":"payoutToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"capMinusFloor","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sharesMinted","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sharesTransferred","type":"uint256"},{"indexed":true,"internalType":"address","name":"upfrontTokenAddr","type":"address"},{"indexed":false,"internalType":"uint256","name":"upfrontTokenAmount","type":"uint256"}],"name":"SilicaPools__VolumeAccountingEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"INVERSE_BASIS_POINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_FILL_FEE_BPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKENID_SALT","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bountyFractionIncreasePerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bountyGracePeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint48","name":"expiry","type":"uint48"},{"internalType":"address","name":"offeredUpfrontToken","type":"address"},{"internalType":"uint128","name":"offeredUpfrontAmount","type":"uint128"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"offeredLongSharesParams","type":"tuple"},{"internalType":"uint128","name":"offeredLongShares","type":"uint128"},{"internalType":"address","name":"requestedUpfrontToken","type":"address"},{"internalType":"uint128","name":"requestedUpfrontAmount","type":"uint128"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"requestedLongSharesParams","type":"tuple"},{"internalType":"uint128","name":"requestedLongShares","type":"uint128"}],"internalType":"struct ISilicaPools.SilicaOrder[]","name":"orders","type":"tuple[]"}],"name":"cancelOrders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"poolParams","type":"tuple[]"},{"internalType":"uint256[]","name":"shares","type":"uint256[]"}],"name":"collateralRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"poolParams","type":"tuple"},{"internalType":"bytes32","name":"orderHash","type":"bytes32"},{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"longRecipient","type":"address"},{"internalType":"address","name":"shortRecipient","type":"address"}],"name":"collateralizedMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"domainSeparatorV4","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"poolParams","type":"tuple[]"}],"name":"endBounty","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"poolParams","type":"tuple"}],"name":"endPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"poolParams","type":"tuple[]"}],"name":"endPools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fillFeeBps","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint48","name":"expiry","type":"uint48"},{"internalType":"address","name":"offeredUpfrontToken","type":"address"},{"internalType":"uint128","name":"offeredUpfrontAmount","type":"uint128"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"offeredLongSharesParams","type":"tuple"},{"internalType":"uint128","name":"offeredLongShares","type":"uint128"},{"internalType":"address","name":"requestedUpfrontToken","type":"address"},{"internalType":"uint128","name":"requestedUpfrontAmount","type":"uint128"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"requestedLongSharesParams","type":"tuple"},{"internalType":"uint128","name":"requestedLongShares","type":"uint128"}],"internalType":"struct ISilicaPools.SilicaOrder","name":"order","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"fraction","type":"uint256"}],"name":"fillOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint48","name":"expiry","type":"uint48"},{"internalType":"address","name":"offeredUpfrontToken","type":"address"},{"internalType":"uint128","name":"offeredUpfrontAmount","type":"uint128"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"offeredLongSharesParams","type":"tuple"},{"internalType":"uint128","name":"offeredLongShares","type":"uint128"},{"internalType":"address","name":"requestedUpfrontToken","type":"address"},{"internalType":"uint128","name":"requestedUpfrontAmount","type":"uint128"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"requestedLongSharesParams","type":"tuple"},{"internalType":"uint128","name":"requestedLongShares","type":"uint128"}],"internalType":"struct ISilicaPools.SilicaOrder[]","name":"orders","type":"tuple[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"},{"internalType":"uint256[]","name":"fractions","type":"uint256[]"}],"name":"fillOrders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"longTokenId","type":"uint256"}],"name":"fromLongTokenId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"shortTokenId","type":"uint256"}],"name":"fromShortTokenId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"maker","type":"address"},{"internalType":"address","name":"taker","type":"address"},{"internalType":"uint48","name":"expiry","type":"uint48"},{"internalType":"address","name":"offeredUpfrontToken","type":"address"},{"internalType":"uint128","name":"offeredUpfrontAmount","type":"uint128"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"offeredLongSharesParams","type":"tuple"},{"internalType":"uint128","name":"offeredLongShares","type":"uint128"},{"internalType":"address","name":"requestedUpfrontToken","type":"address"},{"internalType":"uint128","name":"requestedUpfrontAmount","type":"uint128"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"requestedLongSharesParams","type":"tuple"},{"internalType":"uint128","name":"requestedLongShares","type":"uint128"}],"internalType":"struct ISilicaPools.SilicaOrder","name":"order","type":"tuple"},{"internalType":"bytes32","name":"domainSeparator","type":"bytes32"}],"name":"hashOrder","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"poolParams","type":"tuple"}],"name":"hashPool","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxBountyFraction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"poolParams","type":"tuple[]"}],"name":"maxCollateralRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"orderHash","type":"bytes32"}],"name":"orderCancelled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolHash","type":"bytes32"}],"name":"poolState","outputs":[{"components":[{"internalType":"uint128","name":"collateralMinted","type":"uint128"},{"internalType":"uint128","name":"sharesMinted","type":"uint128"},{"internalType":"uint128","name":"indexShares","type":"uint128"},{"internalType":"uint128","name":"indexInitialBalance","type":"uint128"},{"internalType":"uint48","name":"actualStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"actualEndTimestamp","type":"uint48"},{"internalType":"uint128","name":"balanceChangePerShare","type":"uint128"}],"internalType":"struct ISilicaPools.PoolState","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"longPoolParams","type":"tuple[]"},{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"shortPoolParams","type":"tuple[]"}],"name":"redeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"longParams","type":"tuple"}],"name":"redeemLong","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"shortParams","type":"tuple"}],"name":"redeemShort","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sBountyFractionIncreasePerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sBountyGracePeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sMaxBountyFraction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newIncreaseAmount","type":"uint256"}],"name":"setBountyFractionIncreasePerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newGracePeriod","type":"uint256"}],"name":"setBountyGracePeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newFillFeeBps","type":"uint256"}],"name":"setFillFeeBps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaxFraction","type":"uint256"}],"name":"setMaxBountyFraction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newTreasury","type":"address"}],"name":"setTreasuryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"poolParams","type":"tuple[]"}],"name":"startBounty","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"poolParams","type":"tuple"}],"name":"startPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"poolParams","type":"tuple[]"}],"name":"startPools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolHash","type":"bytes32"}],"name":"toLongTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolHash","type":"bytes32"}],"name":"toShortTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"poolParams","type":"tuple[]"},{"internalType":"uint256[]","name":"shares","type":"uint256[]"}],"name":"viewCollateralRefund","outputs":[{"internalType":"uint256[]","name":"expectedRefunds","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams[]","name":"poolParams","type":"tuple[]"},{"internalType":"address[]","name":"accounts","type":"address[]"}],"name":"viewMaxCollateralRefund","outputs":[{"internalType":"uint256[]","name":"expectedRefund","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"longParams","type":"tuple"},{"internalType":"address","name":"account","type":"address"}],"name":"viewRedeemLong","outputs":[{"internalType":"uint256","name":"expectedPayout","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint128","name":"floor","type":"uint128"},{"internalType":"uint128","name":"cap","type":"uint128"},{"internalType":"address","name":"index","type":"address"},{"internalType":"uint48","name":"targetStartTimestamp","type":"uint48"},{"internalType":"uint48","name":"targetEndTimestamp","type":"uint48"},{"internalType":"address","name":"payoutToken","type":"address"}],"internalType":"struct ISilicaPools.PoolParams","name":"shortParams","type":"tuple"},{"internalType":"address","name":"account","type":"address"}],"name":"viewRedeemShort","outputs":[{"internalType":"uint256","name":"expectedPayout","type":"uint256"}],"stateMutability":"view","type":"function"}]
