0x4a...287c
Unidentified contract edfcc2c9-7858-4cd3-ba1b-e6e04bf425df
Collection
Collection
This contract's source code is verified!
Contract Metadata
Compiler
0.8.19+commit.7dd6d404
Language
Solidity
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
*
* Furthermore, `isContract` will also return true if the target contract within
* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
* which only has an effect at the end of a transaction.
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
/// @dev parameter for minting Timeswap V2 Tokens
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param long0Amount The amount of long0 deposited.
/// @param long1Amount The amount of long1 deposited.
/// @param shortAmount The amount of short deposited.
/// @param data Arbitrary data passed to the callback.
struct TimeswapV2TokenMintCallbackParam {
address token0;
address token1;
uint256 strike;
uint256 maturity;
uint256 long0Amount;
uint256 long1Amount;
uint256 shortAmount;
bytes data;
}
/// @dev parameter for burning Timeswap V2 Tokens
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param long0Amount The amount of long0 withdrawn.
/// @param long1Amount The amount of long1 withdrawn.
/// @param shortAmount The amount of short withdrawn.
/// @param data Arbitrary data passed to the callback, initalize as empty if not required.
struct TimeswapV2TokenBurnCallbackParam {
address token0;
address token1;
uint256 strike;
uint256 maturity;
uint256 long0Amount;
uint256 long1Amount;
uint256 shortAmount;
bytes data;
}
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param liquidity The amount of liquidity increase.
/// @param data data
struct TimeswapV2LiquidityTokenMintCallbackParam {
address token0;
address token1;
uint256 strike;
uint256 maturity;
uint160 liquidityAmount;
bytes data;
}
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param liquidity The amount of liquidity decrease.
/// @param data data
struct TimeswapV2LiquidityTokenBurnCallbackParam {
address token0;
address token1;
uint256 strike;
uint256 maturity;
uint160 liquidityAmount;
bytes data;
}
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param long0Fees The amount of long0 fees withdrawn.
/// @param long1Fees The amount of long1 fees withdrawn.
/// @param shortFees The amount of short fees withdrawn.
/// @param shortReturned The amount of short returned withdrawn.
/// @param data data
struct TimeswapV2LiquidityTokenCollectCallbackParam {
address token0;
address token1;
uint256 strike;
uint256 maturity;
uint256 long0Fees;
uint256 long1Fees;
uint256 shortFees;
uint256 shortReturned;
bytes data;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
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;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
import "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./extensions/IERC1155MetadataURI.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/introspection/ERC165.sol";
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
constructor(string memory uri_) {
_setURI(uri_);
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the `\{id\}` substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(
address[] memory accounts,
uint256[] memory ids
) public view virtual override returns (uint256[] memory) {
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(address from, uint256 id, uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(address from, uint256[] memory ids, uint256[] memory amounts) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `ids` and `amounts` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
// SPDX-License-Identifier: BUSL-1.1
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)
pragma solidity ^0.8.0;
import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import {IERC1155Enumerable} from "../interfaces/IERC1155Enumerable.sol";
/// Extension of {ERC1155} that adds
/// enumerability of all the token ids in the contract as well as all token ids owned by each
/// account.
abstract contract ERC1155Enumerable is IERC1155Enumerable, ERC1155 {
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) private _ownedTokens; // An index of all tokens
// Mapping from address to token ID to index of the owner tokens list
mapping(address => mapping(uint256 => uint256)) private _ownedTokensIndex;
mapping(uint256 => uint256) private _idTotalSupply;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
/// @inheritdoc IERC1155Enumerable
function tokenOfOwnerByIndex(address owner, uint256 index) external view override returns (uint256) {
return _ownedTokens[owner][index];
}
/// @inheritdoc IERC1155Enumerable
function totalIds() external view override returns (uint256) {
return _allTokens.length;
}
/// @inheritdoc IERC1155Enumerable
function totalSupply(uint256 id) external view override returns (uint256) {
return _idTotalSupply[id];
}
/// @inheritdoc IERC1155Enumerable
function tokenByIndex(uint256 index) external view override returns (uint256) {
return _allTokens[index];
}
/// @dev Hook that is called before any token transfer. This includes minting
/// and burning.
function _beforeTokenTransfer(
address,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory
) internal virtual override {
for (uint256 i; i < ids.length; ) {
if (amounts[i] != 0) _addTokenEnumeration(from, to, ids[i], amounts[i]);
unchecked {
++i;
}
}
}
/// @dev Add token enumeration list if necessary.
function _addTokenEnumeration(address from, address to, uint256 id, uint256 amount) internal {
if (from == address(0)) {
if (_idTotalSupply[id] == 0 && _additionalConditionAddTokenToAllTokensEnumeration(id))
_addTokenToAllTokensEnumeration(id);
_idTotalSupply[id] += amount;
}
if (to != address(0) && to != from) {
if (balanceOf(to, id) == 0 && _additionalConditionAddTokenToOwnerEnumeration(to, id))
_addTokenToOwnerEnumeration(to, id);
}
}
/// @dev Any additional condition to add token enumeration when overridden.
function _additionalConditionAddTokenToAllTokensEnumeration(uint256) internal virtual returns (bool) {
return true;
}
/// @dev Any additional condition to add token enumeration when overridden.
function _additionalConditionAddTokenToOwnerEnumeration(address, uint256) internal virtual returns (bool) {
return true;
}
/// @dev Hook that is called after any token transfer. This includes minting
/// and burning.
function _afterTokenTransfer(
address,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory
) internal virtual override {
for (uint256 i; i < ids.length; ) {
if (amounts[i] != 0) _removeTokenEnumeration(from, to, ids[i], amounts[i]);
unchecked {
++i;
}
}
}
/// @dev Remove token enumeration list if necessary.
function _removeTokenEnumeration(address from, address to, uint256 id, uint256 amount) internal {
if (to == address(0)) {
_idTotalSupply[id] -= amount;
if (_idTotalSupply[id] == 0 && _additionalConditionRemoveTokenFromAllTokensEnumeration(id))
_removeTokenFromAllTokensEnumeration(id);
}
if (from != address(0) && from != to) {
if (balanceOf(from, id) == 0 && _additionalConditionRemoveTokenFromOwnerEnumeration(from, id))
_removeTokenFromOwnerEnumeration(from, id);
}
}
/// @dev Any additional condition to remove token enumeration when overridden.
function _additionalConditionRemoveTokenFromAllTokensEnumeration(uint256) internal virtual returns (bool) {
return true;
}
/// @dev Any additional condition to remove token enumeration when overridden.
function _additionalConditionRemoveTokenFromOwnerEnumeration(address, uint256) internal virtual returns (bool) {
return true;
}
/// @dev Private function to add a token to this extension's ownership-tracking data structures.
/// @param to address representing the new owner of the given token ID
/// @param tokenId uint256 ID of the token to be added to the tokens list of the given address
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
_ownedTokensIndex[to][tokenId] = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
}
/// @dev Private function to add a token to this extension's token tracking data structures.
/// @param tokenId uint256 ID of the token to be added to the tokens list
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
/// @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
/// while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
/// gas optimizations e.g. when performing a transfer operation (avoiding double writes).
/// This has O(1) time complexity, but alters the order of the _ownedTokens array.
/// @param from address representing the previous owner of the given token ID
/// @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
uint256 lastTokenIndex = _ownedTokens[from].length - 1;
uint256 tokenIndex = _ownedTokensIndex[from][tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[from][lastTokenId] = tokenIndex;
}
delete _ownedTokensIndex[from][tokenId];
_ownedTokens[from].pop();
}
/// @dev Private function to remove a token from this extension's token tracking data structures.
/// This has O(1) time complexity, but alters the order of the _allTokens array.
/// @param tokenId uint256 ID of the token to be removed from the tokens list
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId;
_allTokensIndex[lastTokenId] = tokenIndex;
}
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
/// @title Library for errors
/// @author Timeswap Labs
/// @dev Common error messages
library Error {
/// @dev Reverts when input is zero.
error ZeroInput();
/// @dev Reverts when output is zero.
error ZeroOutput();
/// @dev Reverts when a value cannot be zero.
error CannotBeZero();
/// @dev Reverts when a pool already have liquidity.
/// @param liquidity The liquidity amount that already existed in the pool.
error AlreadyHaveLiquidity(uint160 liquidity);
/// @dev Reverts when a pool requires liquidity.
error RequireLiquidity();
/// @dev Reverts when a given address is the zero address.
error ZeroAddress();
/// @dev Reverts when the maturity given is not withing uint96.
/// @param maturity The maturity being inquired.
error IncorrectMaturity(uint256 maturity);
/// @dev Reverts when an option of given strike and maturity is still inactive.
/// @param strike The chosen strike.
/// @param maturity The chosen maturity.
error InactiveOption(uint256 strike, uint256 maturity);
/// @dev Reverts when a pool of given strike and maturity is still inactive.
/// @param strike The chosen strike.
/// @param maturity The chosen maturity.
error InactivePool(uint256 strike, uint256 maturity);
/// @dev Reverts when a liquidity token is inactive.
error InactiveLiquidityTokenChoice();
/// @dev Reverts when the square root interest rate is zero.
/// @param strike The chosen strike.
/// @param maturity The chosen maturity.
error ZeroSqrtInterestRate(uint256 strike, uint256 maturity);
/// @dev Reverts when the maturity is already matured.
/// @param maturity The maturity.
/// @param blockTimestamp The current block timestamp.
error AlreadyMatured(uint256 maturity, uint96 blockTimestamp);
/// @dev Reverts when the maturity is still active.
/// @param maturity The maturity.
/// @param blockTimestamp The current block timestamp.
error StillActive(uint256 maturity, uint96 blockTimestamp);
/// @dev Token amount not received.
/// @param minuend The amount being subtracted.
/// @param subtrahend The amount subtracting.
error NotEnoughReceived(uint256 minuend, uint256 subtrahend);
/// @dev The deadline of a transaction has been reached.
/// @param deadline The deadline set.
error DeadlineReached(uint256 deadline);
/// @dev Reverts when input is zero.
function zeroInput() internal pure {
revert ZeroInput();
}
/// @dev Reverts when output is zero.
function zeroOutput() internal pure {
revert ZeroOutput();
}
/// @dev Reverts when a value cannot be zero.
function cannotBeZero() internal pure {
revert CannotBeZero();
}
/// @dev Reverts when a pool already have liquidity.
/// @param liquidity The liquidity amount that already existed in the pool.
function alreadyHaveLiquidity(uint160 liquidity) internal pure {
revert AlreadyHaveLiquidity(liquidity);
}
/// @dev Reverts when a pool requires liquidity.
function requireLiquidity() internal pure {
revert RequireLiquidity();
}
/// @dev Reverts when a given address is the zero address.
function zeroAddress() internal pure {
revert ZeroAddress();
}
/// @dev Reverts when the maturity given is not withing uint96.
/// @param maturity The maturity being inquired.
function incorrectMaturity(uint256 maturity) internal pure {
revert IncorrectMaturity(maturity);
}
/// @dev Reverts when the maturity is already matured.
/// @param maturity The maturity.
/// @param blockTimestamp The current block timestamp.
function alreadyMatured(uint256 maturity, uint96 blockTimestamp) internal pure {
revert AlreadyMatured(maturity, blockTimestamp);
}
/// @dev Reverts when the maturity is still active.
/// @param maturity The maturity.
/// @param blockTimestamp The current block timestamp.
function stillActive(uint256 maturity, uint96 blockTimestamp) internal pure {
revert StillActive(maturity, blockTimestamp);
}
/// @dev The deadline of a transaction has been reached.
/// @param deadline The deadline set.
function deadlineReached(uint256 deadline) internal pure {
revert DeadlineReached(deadline);
}
/// @dev Reverts when an option of given strike and maturity is still inactive.
/// @param strike The chosen strike.
function inactiveOptionChoice(uint256 strike, uint256 maturity) internal pure {
revert InactiveOption(strike, maturity);
}
/// @dev Reverts when a pool of given strike and maturity is still inactive.
/// @param strike The chosen strike.
/// @param maturity The chosen maturity.
function inactivePoolChoice(uint256 strike, uint256 maturity) internal pure {
revert InactivePool(strike, maturity);
}
/// @dev Reverts when the square root interest rate is zero.
/// @param strike The chosen strike.
/// @param maturity The chosen maturity.
function zeroSqrtInterestRate(uint256 strike, uint256 maturity) internal pure {
revert ZeroSqrtInterestRate(strike, maturity);
}
/// @dev Reverts when a liquidity token is inactive.
function inactiveLiquidityTokenChoice() internal pure {
revert InactiveLiquidityTokenChoice();
}
/// @dev Reverts when token amount not received.
/// @param balance The balance amount being subtracted.
/// @param balanceTarget The amount target.
function checkEnough(uint256 balance, uint256 balanceTarget) internal pure {
if (balance < balanceTarget) revert NotEnoughReceived(balance, balanceTarget);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/IERC1155.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/
interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
* transfers.
*/
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
/**
* @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
* `approved`.
*/
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
/**
* @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
*
* If an {URI} event was emitted for `id`, the standard
* https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
* returned by {IERC1155MetadataURI-uri}.
*/
event URI(string value, uint256 indexed id);
/**
* @dev Returns the amount of tokens of token type `id` owned by `account`.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) external view returns (uint256);
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(
address[] calldata accounts,
uint256[] calldata ids
) external view returns (uint256[] memory);
/**
* @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
*
* Emits an {ApprovalForAll} event.
*
* Requirements:
*
* - `operator` cannot be the caller.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address account, address operator) external view returns (bool);
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
// SPDX-License-Identifier: BUSL-1.1
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
/// @title ERC-1155 Token Standard, optional enumeration extension
/// @dev See https://eips.ethereum.org/EIPS/eip-721
interface IERC1155Enumerable is IERC1155 {
/// @dev Returns the total amount of ids with positive supply stored by the contract.
function totalIds() external view returns (uint256);
/// @dev Returns the total supply of a token given its id.
/// @param id The index of the queried token.
function totalSupply(uint256 id) external view returns (uint256);
/// @dev Returns a token ID owned by `owner` at a given `index` of its token list.
/// Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
/// @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
/// Use along with {totalSupply} to enumerate all tokens.
function tokenByIndex(uint256 index) external view returns (uint256);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)
pragma solidity ^0.8.0;
import "../IERC1155.sol";
/**
* @dev Interface of the optional ERC1155MetadataExtension interface, as defined
* in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
*
* _Available since v3.1._
*/
interface IERC1155MetadataURI is IERC1155 {
/**
* @dev Returns the URI for token type `id`.
*
* If the `\{id\}` substring is present in the URI, it must be replaced by
* clients with the actual token type ID.
*/
function uri(uint256 id) external view returns (string memory);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
/**
* @dev _Available since v3.1._
*/
interface IERC1155Receiver is IERC165 {
/**
* @dev Handles the receipt of a single ERC1155 token type. This function is
* called at the end of a `safeTransferFrom` after the balance has been updated.
*
* NOTE: To accept the transfer, this must return
* `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
* (i.e. 0xf23a6e61, or its own function selector).
*
* @param operator The address which initiated the transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param id The ID of the token being transferred
* @param value The amount of tokens being transferred
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
/**
* @dev Handles the receipt of a multiple ERC1155 token types. This function
* is called at the end of a `safeBatchTransferFrom` after the balances have
* been updated.
*
* NOTE: To accept the transfer(s), this must return
* `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
* (i.e. 0xbc197c81, or its own function selector).
*
* @param operator The address which initiated the batch transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param ids An array containing ids of each token being transferred (order and length must match values array)
* @param values An array containing amounts of each token being transferred (order and length must match ids array)
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
import {TimeswapV2OptionPosition} from "../enums/Position.sol";
import {TimeswapV2OptionMintParam, TimeswapV2OptionBurnParam, TimeswapV2OptionSwapParam, TimeswapV2OptionCollectParam} from "../structs/Param.sol";
import {StrikeAndMaturity} from "../structs/StrikeAndMaturity.sol";
/// @title An interface for a contract that deploys Timeswap V2 Option pair contracts
/// @notice A Timeswap V2 Option pair facilitates option mechanics between any two assets that strictly conform
/// to the ERC20 specification.
interface ITimeswapV2Option {
/* ===== EVENT ===== */
/// @dev Emits when a position is transferred.
/// @param strike The strike ratio of token1 per token0 of the position.
/// @param maturity The maturity of the position.
/// @param from The address of the caller of the transferPosition function.
/// @param to The address of the recipient of the position.
/// @param position The type of position transferred. More information in the Position module.
/// @param amount The amount of balance transferred.
event TransferPosition(
uint256 indexed strike,
uint256 indexed maturity,
address from,
address to,
TimeswapV2OptionPosition position,
uint256 amount
);
/// @dev Emits when a mint transaction is called.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param caller The address of the caller of the mint function.
/// @param long0To The address of the recipient of long token0 position.
/// @param long1To The address of the recipient of long token1 position.
/// @param shortTo The address of the recipient of short position.
/// @param token0AndLong0Amount The amount of token0 deposited and long0 minted.
/// @param token1AndLong1Amount The amount of token1 deposited and long1 minted.
/// @param shortAmount The amount of short minted.
event Mint(
uint256 indexed strike,
uint256 indexed maturity,
address indexed caller,
address long0To,
address long1To,
address shortTo,
uint256 token0AndLong0Amount,
uint256 token1AndLong1Amount,
uint256 shortAmount
);
/// @dev Emits when a burn transaction is called.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param caller The address of the caller of the mint function.
/// @param token0To The address of the recipient of token0.
/// @param token1To The address of the recipient of token1.
/// @param token0AndLong0Amount The amount of token0 withdrawn and long0 burnt.
/// @param token1AndLong1Amount The amount of token1 withdrawn and long1 burnt.
/// @param shortAmount The amount of short burnt.
event Burn(
uint256 indexed strike,
uint256 indexed maturity,
address indexed caller,
address token0To,
address token1To,
uint256 token0AndLong0Amount,
uint256 token1AndLong1Amount,
uint256 shortAmount
);
/// @dev Emits when a swap transaction is called.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param caller The address of the caller of the mint function.
/// @param tokenTo The address of the recipient of token0 or token1.
/// @param longTo The address of the recipient of long token0 or long token1.
/// @param isLong0toLong1 The direction of the swap. More information in the Transaction module.
/// @param token0AndLong0Amount If the direction is from long0 to long1, the amount of token0 withdrawn and long0 burnt.
/// If the direction is from long1 to long0, the amount of token0 deposited and long0 minted.
/// @param token1AndLong1Amount If the direction is from long0 to long1, the amount of token1 deposited and long1 minted.
/// If the direction is from long1 to long0, the amount of token1 withdrawn and long1 burnt.
event Swap(
uint256 indexed strike,
uint256 indexed maturity,
address indexed caller,
address tokenTo,
address longTo,
bool isLong0toLong1,
uint256 token0AndLong0Amount,
uint256 token1AndLong1Amount
);
/// @dev Emits when a collect transaction is called.
/// @param strike The strike ratio of token1 per token0 of the option.
/// @param maturity The maturity of the option.
/// @param caller The address of the caller of the mint function.
/// @param token0To The address of the recipient of token0.
/// @param token1To The address of the recipient of token1.
/// @param long0AndToken0Amount The amount of token0 withdrawn.
/// @param long1AndToken1Amount The amount of token1 withdrawn.
/// @param shortAmount The amount of short burnt.
event Collect(
uint256 indexed strike,
uint256 indexed maturity,
address indexed caller,
address token0To,
address token1To,
uint256 long0AndToken0Amount,
uint256 long1AndToken1Amount,
uint256 shortAmount
);
/* ===== VIEW ===== */
/// @dev Returns the factory address that deployed this contract.
function optionFactory() external view returns (address);
/// @dev Returns the first ERC20 token address of the pair.
function token0() external view returns (address);
/// @dev Returns the second ERC20 token address of the pair.
function token1() external view returns (address);
/// @dev Get the strike and maturity of the option in the option enumeration list.
/// @param id The chosen index.
function getByIndex(uint256 id) external view returns (StrikeAndMaturity memory);
/// @dev Number of options being interacted.
function numberOfOptions() external view returns (uint256);
/// @dev Returns the total position of the option.
/// @param strike The strike ratio of token1 per token0 of the position.
/// @param maturity The maturity of the position.
/// @param position The type of position inquired. More information in the Position module.
/// @return balance The total position.
function totalPosition(
uint256 strike,
uint256 maturity,
TimeswapV2OptionPosition position
) external view returns (uint256 balance);
/// @dev Returns the position of an owner of the option.
/// @param strike The strike ratio of token1 per token0 of the position.
/// @param maturity The maturity of the position.
/// @param owner The address of the owner of the position.
/// @param position The type of position inquired. More information in the Position module.
/// @return balance The user position.
function positionOf(
uint256 strike,
uint256 maturity,
address owner,
TimeswapV2OptionPosition position
) external view returns (uint256 balance);
/* ===== UPDATE ===== */
/// @dev Transfer position to another address.
/// @param strike The strike ratio of token1 per token0 of the position.
/// @param maturity The maturity of the position.
/// @param to The address of the recipient of the position.
/// @param position The type of position transferred. More information in the Position module.
/// @param amount The amount of balance transferred.
function transferPosition(
uint256 strike,
uint256 maturity,
address to,
TimeswapV2OptionPosition position,
uint256 amount
) external;
/// @dev Mint position.
/// Mint long token0 position when token0 is deposited.
/// Mint long token1 position when token1 is deposited.
/// @dev Can only be called before the maturity of the pool.
/// @param param The parameters for the mint function.
/// @return token0AndLong0Amount The amount of token0 deposited and long0 minted.
/// @return token1AndLong1Amount The amount of token1 deposited and long1 minted.
/// @return shortAmount The amount of short minted.
/// @return data The additional data return.
function mint(
TimeswapV2OptionMintParam calldata param
)
external
returns (uint256 token0AndLong0Amount, uint256 token1AndLong1Amount, uint256 shortAmount, bytes memory data);
/// @dev Burn short position.
/// Withdraw token0, when long token0 is burnt.
/// Withdraw token1, when long token1 is burnt.
/// @dev Can only be called before the maturity of the pool.
/// @param param The parameters for the burn function.
/// @return token0AndLong0Amount The amount of token0 withdrawn and long0 burnt.
/// @return token1AndLong1Amount The amount of token1 withdrawn and long1 burnt.
/// @return shortAmount The amount of short burnt.
function burn(
TimeswapV2OptionBurnParam calldata param
)
external
returns (uint256 token0AndLong0Amount, uint256 token1AndLong1Amount, uint256 shortAmount, bytes memory data);
/// @dev If the direction is from long token0 to long token1, burn long token0 and mint equivalent long token1,
/// also deposit token1 and withdraw token0.
/// If the direction is from long token1 to long token0, burn long token1 and mint equivalent long token0,
/// also deposit token0 and withdraw token1.
/// @dev Can only be called before the maturity of the pool.
/// @param param The parameters for the swap function.
/// @return token0AndLong0Amount If direction is Long0ToLong1, the amount of token0 withdrawn and long0 burnt.
/// If direction is Long1ToLong0, the amount of token0 deposited and long0 minted.
/// @return token1AndLong1Amount If direction is Long0ToLong1, the amount of token1 deposited and long1 minted.
/// If direction is Long1ToLong0, the amount of token1 withdrawn and long1 burnt.
/// @return data The additional data return.
function swap(
TimeswapV2OptionSwapParam calldata param
) external returns (uint256 token0AndLong0Amount, uint256 token1AndLong1Amount, bytes memory data);
/// @dev Burn short position, withdraw token0 and token1.
/// @dev Can only be called after the maturity of the pool.
/// @param param The parameters for the collect function.
/// @return token0Amount The amount of token0 withdrawn.
/// @return token1Amount The amount of token1 withdrawn.
/// @return shortAmount The amount of short burnt.
function collect(
TimeswapV2OptionCollectParam calldata param
) external returns (uint256 token0Amount, uint256 token1Amount, uint256 shortAmount, bytes memory data);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
/// @title The interface for the contract that deploys Timeswap V2 Option pair contracts
/// @notice The Timeswap V2 Option Factory facilitates creation of Timeswap V2 Options pair.
interface ITimeswapV2OptionFactory {
/* ===== EVENT ===== */
/// @dev Emits when a new Timeswap V2 Option contract is created.
/// @param caller The address of the caller of create function.
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param optionPair The address of the Timeswap V2 Option contract created.
event Create(address indexed caller, address indexed token0, address indexed token1, address optionPair);
/* ===== VIEW ===== */
/// @dev Returns the address of a Timeswap V2 Option.
/// @dev Returns a zero address if the Timeswap V2 Option does not exist.
/// @notice The token0 address must be smaller than token1 address.
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @return optionPair The address of the Timeswap V2 Option contract or a zero address.
function get(address token0, address token1) external view returns (address optionPair);
/// @dev Get the address of the option pair in the option pair enumeration list.
/// @param id The chosen index.
function getByIndex(uint256 id) external view returns (address optionPair);
/// @dev The number of option pairs deployed.
function numberOfPairs() external view returns (uint256);
/* ===== UPDATE ===== */
/// @dev Creates a Timeswap V2 Option based on pair parameters.
/// @dev Cannot create a duplicate Timeswap V2 Option with the same pair parameters.
/// @notice The token0 address must be smaller than token1 address.
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param optionPair The address of the Timeswap V2 Option contract created.
function create(address token0, address token1) external returns (address optionPair);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {TimeswapV2TokenPosition} from "../structs/Position.sol";
import {TimeswapV2TokenMintParam, TimeswapV2TokenBurnParam} from "../structs/Param.sol";
/// @title An interface for TS-V2 token system
/// @notice This interface is used to interact with TS-V2 positions
interface ITimeswapV2Token is IERC1155 {
/// @dev Returns the factory address that deployed this contract.
function optionFactory() external view returns (address);
/// @dev Returns the position Balance of the owner
/// @param owner The owner of the token
/// @param position type of option position (long0, long1, short)
function positionOf(address owner, TimeswapV2TokenPosition calldata position) external view returns (uint256 amount);
/// @dev Transfers position token TimeswapV2Token from `from` to `to`
/// @param from The address to transfer position token from
/// @param to The address to transfer position token to
/// @param position The TimeswapV2Token Position to transfer
/// @param amount The amount of TimeswapV2Token Position to transfer
function transferTokenPositionFrom(
address from,
address to,
TimeswapV2TokenPosition calldata position,
uint256 amount
) external;
/// @dev mints TimeswapV2Token as per postion and amount
/// @param param The TimeswapV2TokenMintParam
/// @return data Arbitrary data
function mint(TimeswapV2TokenMintParam calldata param) external returns (bytes memory data);
/// @dev burns TimeswapV2Token as per postion and amount
/// @param param The TimeswapV2TokenBurnParam
function burn(TimeswapV2TokenBurnParam calldata param) external returns (bytes memory data);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
import {TimeswapV2TokenBurnCallbackParam} from "../../structs/CallbackParam.sol";
interface ITimeswapV2TokenBurnCallback {
/// @dev Callback for `ITimeswapV2Token.burn`
function timeswapV2TokenBurnCallback(
TimeswapV2TokenBurnCallbackParam calldata param
) external returns (bytes memory data);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
import {TimeswapV2TokenMintCallbackParam} from "../../structs/CallbackParam.sol";
interface ITimeswapV2TokenMintCallback {
/// @dev Callback for `ITimeswapV2Token.mint`
function timeswapV2TokenMintCallback(
TimeswapV2TokenMintCallbackParam calldata param
) external returns (bytes memory data);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
import {Error} from "@timeswap-labs/v2-library/contracts/Error.sol";
import {OptionPairLibrary} from "./OptionPair.sol";
import {ITimeswapV2OptionFactory} from "../interfaces/ITimeswapV2OptionFactory.sol";
/// @title library for option utils
/// @author Timeswap Labs
library OptionFactoryLibrary {
using OptionPairLibrary for address;
/// @dev reverts if the factory is the zero address.
error ZeroFactoryAddress();
/// @dev check if the factory address is not zero.
/// @param optionFactory The factory address.
function checkNotZeroFactory(address optionFactory) internal pure {
if (optionFactory == address(0)) revert ZeroFactoryAddress();
}
/// @dev Helper function to get the option pair address.
/// @param optionFactory The address of the option factory.
/// @param token0 The smaller ERC20 address of the pair.
/// @param token1 The larger ERC20 address of the pair.
/// @return optionPair The result option pair address.
function get(address optionFactory, address token0, address token1) internal view returns (address optionPair) {
optionPair = ITimeswapV2OptionFactory(optionFactory).get(token0, token1);
}
/// @dev Helper function to get the option pair address.
/// @notice reverts when the option pair does not exist.
/// @param optionFactory The address of the option factory.
/// @param token0 The smaller ERC20 address of the pair.
/// @param token1 The larger ERC20 address of the pair.
/// @return optionPair The result option pair address.
function getWithCheck(
address optionFactory,
address token0,
address token1
) internal view returns (address optionPair) {
optionPair = get(optionFactory, token0, token1);
if (optionPair == address(0)) Error.zeroAddress();
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
/// @title library for optionPair utils
/// @author Timeswap Labs
library OptionPairLibrary {
/// @dev Reverts when option address is zero.
error ZeroOptionAddress();
/// @dev Reverts when the pair has incorrect format.
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
error InvalidOptionPair(address token0, address token1);
/// @dev Reverts when the Timeswap V2 Option already exist.
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param optionPair The address of the existed Pair contract.
error OptionPairAlreadyExisted(address token0, address token1, address optionPair);
/// @dev Checks if option address is not zero.
/// @param optionPair The option pair address being inquired.
function checkNotZeroAddress(address optionPair) internal pure {
if (optionPair == address(0)) revert ZeroOptionAddress();
}
/// @dev Check if the pair tokens is in correct format.
/// @notice Reverts if token0 is greater than or equal token1.
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
function checkCorrectFormat(address token0, address token1) internal pure {
if (token0 >= token1) revert InvalidOptionPair(token0, token1);
}
/// @dev Check if the pair already existed.
/// @notice Reverts if the pair is not a zero address.
/// @param token0 The first ERC20 token address of the pair.
/// @param token1 The second ERC20 token address of the pair.
/// @param optionPair The address of the existed Pair contract.
function checkDoesNotExist(address token0, address token1, address optionPair) internal pure {
if (optionPair != address(0)) revert OptionPairAlreadyExisted(token0, token1, optionPair);
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
import {Error} from "@timeswap-labs/v2-library/contracts/Error.sol";
import {TimeswapV2OptionMint, TimeswapV2OptionBurn, TimeswapV2OptionSwap, TimeswapV2OptionCollect, TransactionLibrary} from "../enums/Transaction.sol";
/// @dev The parameter to call the mint function.
/// @param strike The strike of the option.
/// @param maturity The maturity of the option.
/// @param long0To The recipient of long0 positions.
/// @param long1To The recipient of long1 positions.
/// @param shortTo The recipient of short positions.
/// @param transaction The type of mint transaction, more information in Transaction module.
/// @param amount0 If transaction is givenTokensAndLongs, the amount of token0 deposited, and amount of long0 position minted.
/// If transaction is givenShorts, the amount of short minted, where the equivalent strike converted amount is long0 positions.
/// @param amount1 If transaction is givenTokensAndLongs, the amount of token1 deposited, and amount of long1 position minted.
/// If transaction is givenShorts, the amount of short minted, where the equivalent strike converted amount is long1 positions.
/// @param data The data to be sent to the function, which will go to the mint callback.
struct TimeswapV2OptionMintParam {
uint256 strike;
uint256 maturity;
address long0To;
address long1To;
address shortTo;
TimeswapV2OptionMint transaction;
uint256 amount0;
uint256 amount1;
bytes data;
}
/// @dev The parameter to call the burn function.
/// @param strike The strike of the option.
/// @param maturity The maturity of the option.
/// @param token0To The recipient of token0 withdrawn.
/// @param token1To The recipient of token1 withdrawn.
/// @param transaction The type of burn transaction, more information in Transaction module.
/// @param amount0 If transaction is givenTokensAndLongs, the amount of token0 withdrawn, and amount of long0 position burnt.
/// If transaction is givenShorts, the amount of short burnt, where the equivalent strike converted amount is long0 positions.
/// @param amount1 If transaction is givenTokensAndLongs, the amount of token1 withdrawn, and amount of long1 position burnt.
/// If transaction is givenShorts, the amount of short burnt, where the equivalent strike converted amount is long1 positions.
/// @param data The data to be sent to the function, which will go to the burn callback.
/// @notice If data length is zero, skips the callback.
struct TimeswapV2OptionBurnParam {
uint256 strike;
uint256 maturity;
address token0To;
address token1To;
TimeswapV2OptionBurn transaction;
uint256 amount0;
uint256 amount1;
bytes data;
}
/// @dev The parameter to call the swap function.
/// @param strike The strike of the option.
/// @param maturity The maturity of the option.
/// @param tokenTo The recipient of token0 when isLong0ToLong1 or token1 when isLong1ToLong0.
/// @param longTo The recipient of long1 positions when isLong0ToLong1 or long0 when isLong1ToLong0.
/// @param isLong0ToLong1 Transform long0 positions to long1 positions when true. Transform long1 positions to long0 positions when false.
/// @param transaction The type of swap transaction, more information in Transaction module.
/// @param amount If isLong0ToLong1 and transaction is GivenToken0AndLong0, this is the amount of token0 withdrawn, and the amount of long0 position burnt.
/// If isLong1ToLong0 and transaction is GivenToken0AndLong0, this is the amount of token0 to be deposited, and the amount of long0 position minted.
/// If isLong0ToLong1 and transaction is GivenToken1AndLong1, this is the amount of token1 to be deposited, and the amount of long1 position minted.
/// If isLong1ToLong0 and transaction is GivenToken1AndLong1, this is the amount of token1 withdrawn, and the amount of long1 position burnt.
/// @param data The data to be sent to the function, which will go to the swap callback.
struct TimeswapV2OptionSwapParam {
uint256 strike;
uint256 maturity;
address tokenTo;
address longTo;
bool isLong0ToLong1;
TimeswapV2OptionSwap transaction;
uint256 amount;
bytes data;
}
/// @dev The parameter to call the collect function.
/// @param strike The strike of the option.
/// @param maturity The maturity of the option.
/// @param token0To The recipient of token0 withdrawn.
/// @param token1To The recipient of token1 withdrawn.
/// @param transaction The type of collect transaction, more information in Transaction module.
/// @param amount If transaction is GivenShort, the amount of short position burnt.
/// If transaction is GivenToken0, the amount of token0 withdrawn.
/// If transaction is GivenToken1, the amount of token1 withdrawn.
/// @param data The data to be sent to the function, which will go to the collect callback.
/// @notice If data length is zero, skips the callback.
struct TimeswapV2OptionCollectParam {
uint256 strike;
uint256 maturity;
address token0To;
address token1To;
TimeswapV2OptionCollect transaction;
uint256 amount;
bytes data;
}
library ParamLibrary {
/// @dev Sanity checks
/// @param param the parameter for mint transaction.
/// @param blockTimestamp the current block timestamp.
function check(TimeswapV2OptionMintParam memory param, uint96 blockTimestamp) internal pure {
if (param.strike == 0) Error.zeroInput();
if (param.maturity > type(uint96).max) Error.incorrectMaturity(param.maturity);
if (param.maturity < blockTimestamp) Error.alreadyMatured(param.maturity, blockTimestamp);
if (param.shortTo == address(0)) Error.zeroAddress();
if (param.long0To == address(0)) Error.zeroAddress();
if (param.long1To == address(0)) Error.zeroAddress();
TransactionLibrary.check(param.transaction);
if (param.amount0 == 0 && param.amount1 == 0) Error.zeroInput();
}
/// @dev Sanity checks
/// @param param the parameter for burn transaction.
/// @param blockTimestamp the current block timestamp.
function check(TimeswapV2OptionBurnParam memory param, uint96 blockTimestamp) internal pure {
if (param.strike == 0) Error.zeroInput();
if (param.maturity > type(uint96).max) Error.incorrectMaturity(param.maturity);
if (param.maturity < blockTimestamp) Error.alreadyMatured(param.maturity, blockTimestamp);
if (param.token0To == address(0)) Error.zeroAddress();
if (param.token1To == address(0)) Error.zeroAddress();
TransactionLibrary.check(param.transaction);
if (param.amount0 == 0 && param.amount1 == 0) Error.zeroInput();
}
/// @dev Sanity checks
/// @param param the parameter for swap transaction.
/// @param blockTimestamp the current block timestamp.
function check(TimeswapV2OptionSwapParam memory param, uint96 blockTimestamp) internal pure {
if (param.strike == 0) Error.zeroInput();
if (param.maturity > type(uint96).max) Error.incorrectMaturity(param.maturity);
if (param.maturity < blockTimestamp) Error.alreadyMatured(param.maturity, blockTimestamp);
if (param.tokenTo == address(0)) Error.zeroAddress();
if (param.longTo == address(0)) Error.zeroAddress();
TransactionLibrary.check(param.transaction);
if (param.amount == 0) Error.zeroInput();
}
/// @dev Sanity checks
/// @param param the parameter for collect transaction.
/// @param blockTimestamp the current block timestamp.
function check(TimeswapV2OptionCollectParam memory param, uint96 blockTimestamp) internal pure {
if (param.strike == 0) Error.zeroInput();
if (param.maturity > type(uint96).max) Error.incorrectMaturity(param.maturity);
if (param.maturity >= blockTimestamp) Error.stillActive(param.maturity, blockTimestamp);
if (param.token0To == address(0)) Error.zeroAddress();
if (param.token1To == address(0)) Error.zeroAddress();
TransactionLibrary.check(param.transaction);
if (param.amount == 0) Error.zeroInput();
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
/// @dev The three type of native token positions.
/// @dev Long0 is denominated as the underlying Token0.
/// @dev Long1 is denominated as the underlying Token1.
/// @dev When strike greater than uint128 then Short is denominated as Token0 (the base token denomination).
/// @dev When strike is uint128 then Short is denominated as Token1 (the base token denomination).
enum TimeswapV2OptionPosition {
Long0,
Long1,
Short
}
/// @title library for position utils
/// @author Timeswap Labs
/// @dev Helper functions for the TimeswapOptionPosition enum.
library PositionLibrary {
/// @dev Reverts when the given type of position is invalid.
error InvalidPosition();
/// @dev Checks that the position input is correct.
/// @param position The position input.
function check(TimeswapV2OptionPosition position) internal pure {
if (uint256(position) >= 3) revert InvalidPosition();
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
/// @title library for renentrancy protection
/// @author Timeswap Labs
library ReentrancyGuard {
/// @dev Reverts when their is a reentrancy to a single option.
error NoReentrantCall();
/// @dev Reverts when the option, pool, or token id is not interacted yet.
error NotInteracted();
/// @dev The initial state which must be change to NOT_ENTERED when first interacting.
uint96 internal constant NOT_INTERACTED = 0;
/// @dev The initial and ending state of balanceTarget in the Option struct.
uint96 internal constant NOT_ENTERED = 1;
/// @dev The state where the contract is currently being interacted with.
uint96 internal constant ENTERED = 2;
/// @dev Check if there is a reentrancy in an option.
/// @notice Reverts when balanceTarget is not zero.
/// @param reentrancyGuard The balance being inquired.
function check(uint96 reentrancyGuard) internal pure {
if (reentrancyGuard == NOT_INTERACTED) revert NotInteracted();
if (reentrancyGuard == ENTERED) revert NoReentrantCall();
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
/// @dev A data with strike and maturity data.
/// @param strike The strike.
/// @param maturity The maturity.
struct StrikeAndMaturity {
uint256 strike;
uint256 maturity;
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import {ITimeswapV2Option} from "@timeswap-labs/v2-option/contracts/interfaces/ITimeswapV2Option.sol";
import {OptionFactoryLibrary} from "@timeswap-labs/v2-option/contracts/libraries/OptionFactory.sol";
import {ReentrancyGuard} from "@timeswap-labs/v2-pool/contracts/libraries/ReentrancyGuard.sol";
import {TimeswapV2OptionPosition} from "@timeswap-labs/v2-option/contracts/enums/Position.sol";
import {ITimeswapV2Token} from "./interfaces/ITimeswapV2Token.sol";
import {ITimeswapV2TokenMintCallback} from "./interfaces/callbacks/ITimeswapV2TokenMintCallback.sol";
import {ITimeswapV2TokenBurnCallback} from "./interfaces/callbacks/ITimeswapV2TokenBurnCallback.sol";
import {ERC1155Enumerable} from "./base/ERC1155Enumerable.sol";
import {TimeswapV2TokenPosition, PositionLibrary} from "./structs/Position.sol";
import {TimeswapV2TokenMintParam, TimeswapV2TokenBurnParam, ParamLibrary} from "./structs/Param.sol";
import {TimeswapV2TokenMintCallbackParam, TimeswapV2TokenBurnCallbackParam} from "./structs/CallbackParam.sol";
import {Error} from "@timeswap-labs/v2-library/contracts/Error.sol";
/// @title
/// @author Timeswap Labs
/// @notice TimeswapV2Token tokenizes the TimeswapV2 native option positions (long0, long1, short)
contract TimeswapV2Token is ITimeswapV2Token, ERC1155Enumerable {
using ReentrancyGuard for uint96;
using PositionLibrary for TimeswapV2TokenPosition;
address public immutable optionFactory;
mapping(bytes32 => uint96) private reentrancyGuards;
mapping(uint256 => TimeswapV2TokenPosition) private _timeswapV2TokenPositions;
mapping(bytes32 => uint256) private _timeswapV2TokenPositionIds;
uint256 private counter;
constructor(address chosenOptionFactory, string memory uri) ERC1155("Timeswap V2 Token") {
optionFactory = chosenOptionFactory;
_setURI(uri);
}
/// @dev internal function to change interaction level if any
function changeInteractedIfNecessary(address token0, address token1, uint256 strike, uint256 maturity) private {
bytes32 key = keccak256(abi.encode(token0, token1, strike, maturity));
if (reentrancyGuards[key] == ReentrancyGuard.NOT_INTERACTED) reentrancyGuards[key] = ReentrancyGuard.NOT_ENTERED;
}
/// @dev internal function to start the reentrancy guard
function raiseGuard(address token0, address token1, uint256 strike, uint256 maturity) private {
bytes32 key = keccak256(abi.encode(token0, token1, strike, maturity));
reentrancyGuards[key].check();
reentrancyGuards[key] = ReentrancyGuard.ENTERED;
}
/// @dev internal function to end the reentrancy guard
function lowerGuard(address token0, address token1, uint256 strike, uint256 maturity) private {
bytes32 key = keccak256(abi.encode(token0, token1, strike, maturity));
reentrancyGuards[key] = ReentrancyGuard.NOT_ENTERED;
}
/// @inheritdoc ITimeswapV2Token
function positionOf(
address owner,
TimeswapV2TokenPosition calldata timeswapV2TokenPosition
) public view returns (uint256 amount) {
amount = ERC1155.balanceOf(owner, _timeswapV2TokenPositionIds[timeswapV2TokenPosition.toKey()]);
}
/// @inheritdoc ITimeswapV2Token
function transferTokenPositionFrom(
address from,
address to,
TimeswapV2TokenPosition calldata timeswapV2TokenPosition,
uint256 amount
) external override {
safeTransferFrom(from, to, _timeswapV2TokenPositionIds[timeswapV2TokenPosition.toKey()], (amount), bytes(""));
}
/// @inheritdoc ITimeswapV2Token
function mint(TimeswapV2TokenMintParam calldata param) external override returns (bytes memory data) {
ParamLibrary.check(param);
changeInteractedIfNecessary(param.token0, param.token1, param.strike, param.maturity);
raiseGuard(param.token0, param.token1, param.strike, param.maturity);
address optionPair = OptionFactoryLibrary.getWithCheck(optionFactory, param.token0, param.token1);
uint256 long0BalanceTarget;
// mints TimeswapV2Token in case of the long0 position
if (param.long0Amount != 0) {
// get the initial balance of the long0 position and add the long0 amount to mint
long0BalanceTarget =
ITimeswapV2Option(optionPair).positionOf(
param.strike,
param.maturity,
address(this),
TimeswapV2OptionPosition.Long0
) +
param.long0Amount;
TimeswapV2TokenPosition memory timeswapV2TokenPosition = TimeswapV2TokenPosition({
token0: param.token0,
token1: param.token1,
strike: param.strike,
maturity: param.maturity,
position: TimeswapV2OptionPosition.Long0
});
bytes32 key = timeswapV2TokenPosition.toKey();
// get the unique id of the TimeswapV2Token position
uint256 id = _timeswapV2TokenPositionIds[key];
// if the id is 0, it means that the position has not been minted yet
if (id == 0) {
id = (++counter);
_timeswapV2TokenPositions[id] = timeswapV2TokenPosition;
_timeswapV2TokenPositionIds[key] = id;
}
// mint the TimeswapV2Token long0 position
_mint(param.long0To, id, (param.long0Amount), bytes(""));
}
uint256 long1BalanceTarget;
// mints TimeswapV2Token in case of the long1 position
if (param.long1Amount != 0) {
// get the initial balance of the long1 position and add the long1 amount to mint
long1BalanceTarget =
ITimeswapV2Option(optionPair).positionOf(
param.strike,
param.maturity,
address(this),
TimeswapV2OptionPosition.Long1
) +
param.long1Amount;
TimeswapV2TokenPosition memory timeswapV2TokenPosition = TimeswapV2TokenPosition({
token0: param.token0,
token1: param.token1,
strike: param.strike,
maturity: param.maturity,
position: TimeswapV2OptionPosition.Long1
});
bytes32 key = timeswapV2TokenPosition.toKey();
// get the unique id of the TimeswapV2Token position
uint256 id = _timeswapV2TokenPositionIds[key];
// if the id is 0, it means that the position has not been minted yet
if (id == 0) {
id = (++counter);
_timeswapV2TokenPositions[id] = timeswapV2TokenPosition;
_timeswapV2TokenPositionIds[key] = id;
}
// mint the TimeswapV2Token long1 position
_mint(param.long1To, id, (param.long1Amount), bytes(""));
}
uint256 shortBalanceTarget;
// mints TimeswapV2Token in case of the short position
if (param.shortAmount != 0) {
// get the initial balance of the short position and add the short amount to mint
shortBalanceTarget =
ITimeswapV2Option(optionPair).positionOf(
param.strike,
param.maturity,
address(this),
TimeswapV2OptionPosition.Short
) +
param.shortAmount;
TimeswapV2TokenPosition memory timeswapV2TokenPosition = TimeswapV2TokenPosition({
token0: param.token0,
token1: param.token1,
strike: param.strike,
maturity: param.maturity,
position: TimeswapV2OptionPosition.Short
});
bytes32 key = timeswapV2TokenPosition.toKey();
// get the unique id of the TimeswapV2Token position
uint256 id = _timeswapV2TokenPositionIds[key];
// if the id is 0, it means that the position has not been minted yet
if (id == 0) {
id = (++counter);
_timeswapV2TokenPositions[id] = timeswapV2TokenPosition;
_timeswapV2TokenPositionIds[key] = id;
}
// mint the TimeswapV2Token short position
_mint(param.shortTo, id, (param.shortAmount), bytes(""));
}
// ask the msg.sender to transfer the long0/long1/short amount to the this contract
data = ITimeswapV2TokenMintCallback(msg.sender).timeswapV2TokenMintCallback(
TimeswapV2TokenMintCallbackParam({
token0: param.token0,
token1: param.token1,
strike: param.strike,
maturity: param.maturity,
long0Amount: param.long0Amount,
long1Amount: param.long1Amount,
shortAmount: param.shortAmount,
data: param.data
})
);
// check if the long0 position token balance target is achieved. If not, revert the transaction
if (param.long0Amount != 0)
Error.checkEnough(
ITimeswapV2Option(optionPair).positionOf(
param.strike,
param.maturity,
address(this),
TimeswapV2OptionPosition.Long0
),
long0BalanceTarget
);
// check if the long1 position token balance target is achieved. If not, revert the transaction
if (param.long1Amount != 0)
Error.checkEnough(
ITimeswapV2Option(optionPair).positionOf(
param.strike,
param.maturity,
address(this),
TimeswapV2OptionPosition.Long1
),
long1BalanceTarget
);
// check if the short position token balance target is achieved. If not, revert the transaction
if (param.shortAmount != 0)
Error.checkEnough(
ITimeswapV2Option(optionPair).positionOf(
param.strike,
param.maturity,
address(this),
TimeswapV2OptionPosition.Short
),
shortBalanceTarget
);
lowerGuard(param.token0, param.token1, param.strike, param.maturity);
}
/// @inheritdoc ITimeswapV2Token
function burn(TimeswapV2TokenBurnParam calldata param) external override returns (bytes memory data) {
ParamLibrary.check(param);
raiseGuard(param.token0, param.token1, param.strike, param.maturity);
address optionPair = OptionFactoryLibrary.getWithCheck(optionFactory, param.token0, param.token1);
// case when the long0 position is to be burned
if (param.long0Amount != 0)
ITimeswapV2Option(optionPair).transferPosition(
param.strike,
param.maturity,
param.long0To,
TimeswapV2OptionPosition.Long0,
param.long0Amount
);
// case when the long1 position is to be burned
if (param.long1Amount != 0)
// transfer the underlying equivalent long1 position amount to address of the recipient of long1 position.
ITimeswapV2Option(optionPair).transferPosition(
param.strike,
param.maturity,
param.long1To,
TimeswapV2OptionPosition.Long1,
param.long1Amount
);
// case when the short position is to be burned
if (param.shortAmount != 0)
ITimeswapV2Option(optionPair).transferPosition(
param.strike,
param.maturity,
param.shortTo,
TimeswapV2OptionPosition.Short,
param.shortAmount
);
if (param.data.length != 0)
data = ITimeswapV2TokenBurnCallback(msg.sender).timeswapV2TokenBurnCallback(
TimeswapV2TokenBurnCallbackParam({
token0: param.token0,
token1: param.token1,
strike: param.strike,
maturity: param.maturity,
long0Amount: param.long0Amount,
long1Amount: param.long1Amount,
shortAmount: param.shortAmount,
data: param.data
})
);
// case when the long0 position is to be burned
if (param.long0Amount != 0) {
TimeswapV2TokenPosition memory timeswapV2TokenPosition = TimeswapV2TokenPosition({
token0: param.token0,
token1: param.token1,
strike: param.strike,
maturity: param.maturity,
position: TimeswapV2OptionPosition.Long0
});
// burn the TimeswapV2Token representing long0 position
_burn(msg.sender, _timeswapV2TokenPositionIds[timeswapV2TokenPosition.toKey()], param.long0Amount);
}
// case when the long1 position is to be burned
if (param.long1Amount != 0) {
TimeswapV2TokenPosition memory timeswapV2TokenPosition = TimeswapV2TokenPosition({
token0: param.token0,
token1: param.token1,
strike: param.strike,
maturity: param.maturity,
position: TimeswapV2OptionPosition.Long1
});
// burn the TimeswapV2Token representing long1 position
_burn(msg.sender, _timeswapV2TokenPositionIds[timeswapV2TokenPosition.toKey()], param.long1Amount);
}
// case when the short position is to be burned
if (param.shortAmount != 0) {
TimeswapV2TokenPosition memory timeswapV2TokenPosition = TimeswapV2TokenPosition({
token0: param.token0,
token1: param.token1,
strike: param.strike,
maturity: param.maturity,
position: TimeswapV2OptionPosition.Short
});
// burn the TimeswapV2Token representing short position
_burn(msg.sender, _timeswapV2TokenPositionIds[timeswapV2TokenPosition.toKey()], param.shortAmount);
}
// stop the guard of reentrancy
lowerGuard(param.token0, param.token1, param.strike, param.maturity);
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.8;
/// @dev The different input for the mint transaction.
enum TimeswapV2OptionMint {
GivenTokensAndLongs,
GivenShorts
}
/// @dev The different input for the burn transaction.
enum TimeswapV2OptionBurn {
GivenTokensAndLongs,
GivenShorts
}
/// @dev The different input for the swap transaction.
enum TimeswapV2OptionSwap {
GivenToken0AndLong0,
GivenToken1AndLong1
}
/// @dev The different input for the collect transaction.
enum TimeswapV2OptionCollect {
GivenShort,
GivenToken0,
GivenToken1
}
/// @title library for transaction checks
/// @author Timeswap Labs
/// @dev Helper functions for the all enums in this module.
library TransactionLibrary {
/// @dev Reverts when the given type of transaction is invalid.
error InvalidTransaction();
/// @dev checks that the given input is correct.
/// @param transaction the mint transaction input.
function check(TimeswapV2OptionMint transaction) internal pure {
if (uint256(transaction) >= 2) revert InvalidTransaction();
}
/// @dev checks that the given input is correct.
/// @param transaction the burn transaction input.
function check(TimeswapV2OptionBurn transaction) internal pure {
if (uint256(transaction) >= 2) revert InvalidTransaction();
}
/// @dev checks that the given input is correct.
/// @param transaction the swap transaction input.
function check(TimeswapV2OptionSwap transaction) internal pure {
if (uint256(transaction) >= 2) revert InvalidTransaction();
}
/// @dev checks that the given input is correct.
/// @param transaction the collect transaction input.
function check(TimeswapV2OptionCollect transaction) internal pure {
if (uint256(transaction) >= 3) revert InvalidTransaction();
}
}
{
"compilationTarget": {
"@timeswap-labs/v2-token/contracts/TimeswapV2Token.sol": "TimeswapV2Token"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": []
}[{"inputs":[{"internalType":"address","name":"chosenOptionFactory","type":"address"},{"internalType":"string","name":"uri","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"maturity","type":"uint256"}],"name":"IncorrectMaturity","type":"error"},{"inputs":[],"name":"NoReentrantCall","type":"error"},{"inputs":[{"internalType":"uint256","name":"minuend","type":"uint256"},{"internalType":"uint256","name":"subtrahend","type":"uint256"}],"name":"NotEnoughReceived","type":"error"},{"inputs":[],"name":"NotInteracted","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroInput","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":[{"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":[{"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":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"strike","type":"uint256"},{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"address","name":"long0To","type":"address"},{"internalType":"address","name":"long1To","type":"address"},{"internalType":"address","name":"shortTo","type":"address"},{"internalType":"uint256","name":"long0Amount","type":"uint256"},{"internalType":"uint256","name":"long1Amount","type":"uint256"},{"internalType":"uint256","name":"shortAmount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct TimeswapV2TokenBurnParam","name":"param","type":"tuple"}],"name":"burn","outputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"nonpayable","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":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"strike","type":"uint256"},{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"address","name":"long0To","type":"address"},{"internalType":"address","name":"long1To","type":"address"},{"internalType":"address","name":"shortTo","type":"address"},{"internalType":"uint256","name":"long0Amount","type":"uint256"},{"internalType":"uint256","name":"long1Amount","type":"uint256"},{"internalType":"uint256","name":"shortAmount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct TimeswapV2TokenMintParam","name":"param","type":"tuple"}],"name":"mint","outputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"optionFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"strike","type":"uint256"},{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"enum TimeswapV2OptionPosition","name":"position","type":"uint8"}],"internalType":"struct TimeswapV2TokenPosition","name":"timeswapV2TokenPosition","type":"tuple"}],"name":"positionOf","outputs":[{"internalType":"uint256","name":"amount","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":"amounts","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":"amount","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalIds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"strike","type":"uint256"},{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"enum TimeswapV2OptionPosition","name":"position","type":"uint8"}],"internalType":"struct TimeswapV2TokenPosition","name":"timeswapV2TokenPosition","type":"tuple"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferTokenPositionFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]