AssetRegistry01

{{
  "language": "Solidity",
  "sources": {
    "contracts/AssetRegistry01.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;


import "./ownable.sol";
import "./IUniswapV3Factory.sol";


interface IUniswapV3Pool {
	function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes calldata data) external returns (int256 amount0, int256 amount1);
	function token0() external view returns (address);
	function token1() external view returns (address);
}


contract AssetRegistry01 is IUniswapV3Factory, Ownable {
	mapping(address => mapping(address => address)) pools;

	constructor() {
		emit FeeAmountEnabled(10000, 200);
	}

	function registerSwapVenue(address poolAddress) external onlyOwner {
		IUniswapV3Pool pool = IUniswapV3Pool(poolAddress);
		address token0 = pool.token0();
		address token1 = pool.token1();

		pools[token0][token1] = poolAddress;

		emit PoolCreated(token0, token1, 10000, 200, poolAddress);
	}

	//
	//  UniswapV3 Emulation Functions
	//

	function feeAmountTickSpacing(uint24 fee) external view returns (int24) {
		// Pretend to support 1%
		return int24(uint24(fee == 10000 ? 200 : 0));
	}

	/// @notice Returns the pool address for a given pair of tokens and a fee, or address 0 if it does not exist
	/// @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order
	/// @param tokenA The contract address of either token0 or token1
	/// @param tokenB The contract address of the other token
	/// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
	/// @return pool The pool address
	function getPool(address tokenA, address tokenB, uint24 fee) external view returns (address pool) {
		return pools[tokenA][tokenB];
	}

	function createPool(address tokenA, address tokenB, uint24 fee) external returns (address pool) {
		revert("Not supported");
	}

	function setOwner(address _owner) external onlyOwner {

		emit OwnerChanged(owner(), _owner);

		_transferOwnership(_owner);
	}

	function enableFeeAmount(uint24 fee, int24 tickSpacing) external {
		revert("Not supported");
	}
	
}"
    },
    "contracts/IUniswapV3Factory.sol": {
      "content": "// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;


interface IUniswapV3Factory {
    /// @notice Emitted when the owner of the factory is changed
    /// @param oldOwner The owner before the owner was changed
    /// @param newOwner The owner after the owner was changed
    event OwnerChanged(address indexed oldOwner, address indexed newOwner);
	
	/// @notice Emitted when a pool is created
	/// @param token0 The first token of the pool by address sort order
	/// @param token1 The second token of the pool by address sort order
	/// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
	/// @param tickSpacing The minimum number of ticks between initialized ticks
	/// @param pool The address of the created pool
	event PoolCreated(
		address indexed token0,
		address indexed token1,
		uint24 indexed fee,
		int24 tickSpacing,
		address pool
	);

	/// @notice Emitted when a new fee amount is enabled for pool creation via the factory
	/// @param fee The enabled fee, denominated in hundredths of a bip
	/// @param tickSpacing The minimum number of ticks between initialized ticks for pools created with the given fee
	event FeeAmountEnabled(uint24 indexed fee, int24 indexed tickSpacing);

	/// @notice Returns the current owner of the factory
	/// @dev Can be changed by the current owner via setOwner
	/// @return The address of the factory owner
	//function owner() external view returns (address);

	/// @notice Returns the tick spacing for a given fee amount, if enabled, or 0 if not enabled
	/// @dev A fee amount can never be removed, so this value should be hard coded or cached in the calling context
	/// @param fee The enabled fee, denominated in hundredths of a bip. Returns 0 in case of unenabled fee
	/// @return The tick spacing
	function feeAmountTickSpacing(uint24 fee) external view returns (int24);

	/// @notice Returns the pool address for a given pair of tokens and a fee, or address 0 if it does not exist
	/// @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order
	/// @param tokenA The contract address of either token0 or token1
	/// @param tokenB The contract address of the other token
	/// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
	/// @return pool The pool address
	function getPool(
		address tokenA,
		address tokenB,
		uint24 fee
	) external view returns (address pool);

	/// @notice Creates a pool for the given two tokens and fee
	/// @param tokenA One of the two tokens in the desired pool
	/// @param tokenB The other of the two tokens in the desired pool
	/// @param fee The desired fee for the pool
	/// @dev tokenA and tokenB may be passed in either order: token0/token1 or token1/token0. tickSpacing is retrieved
	/// from the fee. The call will revert if the pool already exists, the fee is invalid, or the token arguments
	/// are invalid.
	/// @return pool The address of the newly created pool
	function createPool(
		address tokenA,
		address tokenB,
		uint24 fee
	) external returns (address pool);

	/// @notice Updates the owner of the factory
	/// @dev Must be called by the current owner
	/// @param _owner The new owner of the factory
	function setOwner(address _owner) external;

	/// @notice Enables a fee amount with the given tickSpacing
	/// @dev Fee amounts may never be removed once enabled
	/// @param fee The fee amount to enable, denominated in hundredths of a bip (i.e. 1e-6)
	/// @param tickSpacing The spacing between ticks to be enforced for all pools created with the given fee amount
	function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
}
"
    },
    "contracts/ownable.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;


abstract contract Context {
	function _msgSender() internal view virtual returns (address) {
		return msg.sender;
	}

	function _msgData() internal view virtual returns (bytes calldata) {
		return msg.data;
	}
}


abstract contract Ownable is Context {
	address private _owner;

	event OwnershipTransferred(
		address indexed previousOwner,
		address indexed newOwner
	);

	constructor() {
		_transferOwnership(_msgSender());
	}

	modifier onlyOwner() {
		_checkOwner();
		_;
	}

	function owner() public view virtual returns (address) {
		return _owner;
	}

	function _checkOwner() internal view virtual {
		require(owner() == _msgSender(), "Ownable: caller is not the owner");
	}

	function renounceOwnership() public virtual onlyOwner {
		_transferOwnership(address(0));
	}

	function transferOwnership(address newOwner) public virtual onlyOwner {
		require(newOwner != address(0), "Ownable: new owner is the zero address");
		_transferOwnership(newOwner);
	}

	function _transferOwnership(address newOwner) internal virtual {
		address oldOwner = _owner;
		_owner = newOwner;
		emit OwnershipTransferred(oldOwner, newOwner);
	}
}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 65536
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}