# Factory The Factory smart contract oversees the full functionality of token pair registration and transactions in KLAYswap. It is also a token contract for KLAYswap's KSP governance token that complies with the KIP7 standard, and a smart contract that implements all functions related to KSP mining. ## Code Github Link: (Will be updated after official launch) ## Address * Cypress :[ 0xc6a2ad8cc6e4a7e08fc37cc5954be07d499e7654](https://scope.klaytn.com/account/0xc6a2ad8cc6e4a7e08fc37cc5954be07d499e7654?tabId=txList) ## Events, Read-Only Functions, and State-Changing Functions {% tabs %} {% tab title="Events" %} ## Events #### Transfer ```solidity event Transfer(address indexed from, address indexed to, uint amount); ``` * Event for the movement and burning of KSP tokens * A [KIP7 Standard](https://kips.klaytn.com/KIPs/kip-7) Event #### Approval ```solidity event Approval(address indexed holder, address indexed spender, uint amount); ``` * Event for KSP token approval * A [KIP7 Standard](https://kips.klaytn.com/KIPs/kip-7) Event #### ChangeCreateFee ```solidity event ChangeCreateFee(uint _createFee); ``` * An event to change the Pool Contract Creation Fee when adding a new liquidity pool pair #### ChangeTeamWallet ```solidity event ChangeTeamWallet(address _teamWallet); ``` * Event to change the development team wallet #### ClaimTeamAward ```solidity event ClaimTeamAward(uint award, uint totalAward); ``` * Event to claim the development and stabilization commission #### ChangeNextOwner ```solidity event ChangeNextOwner(address nextOwner); ``` * Event to pre-register new owner * owner will be governance smart contract (In Intial period before KSP distributed, DEV team have owner permission) #### ChangeOwner ```solidity event ChangeOwner(address owner); ``` * Event that completes changing the owner #### CreatePool ```solidity event CreatePool(address tokenA, uint amountA, address tokenB, uint amountB, uint fee, address exchange, uint exid); ``` * Event to create new liquidity pool * parameters * `tokenA` : A token address in pair * `amountA` : A token amount in pool * `tokenB` : B token address in pair * `amountB` : B token amount in pool * `fee` : pool fee rate * `exchange` : exchange contract address of this pool * `exid` : exchange id #### ExchangePos ```solidity event ExchangePos(address tokenA, uint amountA, address tokenB, uint amountB); ``` * Positive exchange Event * parameters * `tokenA` : User input tokenA address * `amountA` : User input tokenA amount * `tokenB` : User get tokenB address * `amountB` : User get tokenB amount #### ExchangeNeg ```solidity event ExchangeNeg(address tokenA, uint amountA, address tokenB, uint amountB); ``` * Negative exchange Event * parameters * `tokenA` : User input tokenA address * `amountA` : User input tokenA amount * `tokenB` : User get tokenB address * `amountB` : User get tokenB amountB ## {% endtab %} {% tab title="Read-Only Functions" %} ## Read-Only Functions #### name * KlaySwap Protocol #### symbol * KSP #### decimals * 18 #### totalSupply * 126144000000000000000000000 = 126144000 KSP * There is only one case in which the total supply can be changed: * A decrease due to fee payments for adding new liquidity pairs #### balanceOf * The amount of KSP held in each address #### allowance * Status of approval to spender for each address #### owner * Governance Contract Address #### nextOwner * The next Governance Contract Address set in advance. #### miningAmount * The total mining amount * This cannot be changed after a contract is deployed #### halfLife * The block unit that proceeds with halving * This cannot be changed after a contract is deployed #### minableBlock * The block number that starts mining #### unfreezeBlock * The block number that makes KSP token transfers possible #### teamRatio * The ratio of the mined amount given to the developement team for the first two years. #### pools * List of liquidity pool pairings * Each item saves the smart contract address of the liquidity pool #### poolExist * Returns if the contract for the given liquidiy pool pair exists #### tokenToPool * The contract address corresponding to the tokenA, tokenB pair * When the addresses of tokenA and tokenB are inputted, this returns the contract address of the corresponding pairing * Returns the same contract address regardless of the order of the liquidity pool pairing tokens: tokenToPool\[tokenA]\[tokenB] == tokenToPool\[tokenB]\[tokenA] #### createFee * The amount of KSP that must be paired to create a new liquidity pool pair #### teamWallet * The address to which the development team can claim their reward #### teamAward * The team reward amount that has already been claimed #### mined ```solidity function mined() public view returns (uint) ``` * Returns the KSP amount mined so far * This amount includes the quantity already claimed and the quantity to be claimed * The teamAward quantity is exempted from this amount #### estimatePos ```solidity function estimatePos(address inToken, uint inAmount, address outToken) private view returns (uint) ``` * Returns the possible quantity received for a POS transaction. * Parameters * `inToken` : token address for payment * `inAmount` : amount of tokens for payment * `outToken` : token address for receiving **estimateNeg** ```solidity function estimateNeg(address inToken, address outToken, uint outAmount) private view returns (uint) ``` * Function to return the amount of tokens that need to be paid for a NEG transaction. * Parameters * `inToken` : token address for payment * `outToken` : token address for receiving * `outAmount` : amount of tokens to receive #### getPoolCount ```solidity function getPoolCount() public view returns (uint) ``` * Returns the current number of registered liquidity pools. #### getPoolAddress ```solidity function getPoolAddress(uint idx) public view returns (address) ``` * Returns the liquidity pair contract address of the pair's index. ## {% endtab %} {% tab title="State-Changing Functions" %} ## State-Changing Functions #### transfer ```solidity function transfer(address _to, uint _value) public returns (bool) ``` * KIP7 Standard * Method to transfer KSP tokens #### transferFrom ```solidity function transferFrom(address _from, address _to, uint _value) public returns (bool) ``` * KIP7 Standard * Method to transfer tokens on behalf of the approved wallet #### approve ```solidity function approve(address _spender, uint _value) public returns (bool) ``` * KIP7 Standard * Method to approve a transfer as much as value to spender #### changeNextOwner ```solidity function changeNextOwner(address _nextOwner) public ``` * Method to set the next Owner in advance before changing Owner * only owner #### changeOwner ```solidity function changeOwner() public ``` * Method for the next Owner to change the actual Owner * only nextOwner #### changeCreateFee ```solidity function changeCreateFee(uint _createFee) public ``` * Method that changes KSP fees when liquidity pairs are added * only Owner #### changeTeamWallet ```solidity function changeTeamWallet(address _teamWallet) public ``` * Method to change the developer wallet * only owner #### changePoolFee ```solidity function changePoolFee(address tokenA, address tokenB, uint fee) public ``` * Method to change transaction fees for each liquidity pair * only owner #### changeMiningRate ```solidity function changeMiningRate(address[] memory tokenA, address[] memory tokenB, uint[] memory rate) public ``` * Method to change the mining weight per liquidity pair * All pairs for mining must be changed at once * The rate of each pair is between 1 and 100 * The sum of rates for all pairs is 100 * only owner * Parameters * `tokenA` : list of addresses of the first token pair * `tokenB` : list of addresses of the second token pair * `rate` : list of mining rate for a pair #### claimTeamAward ```solidity function claimTeamAward() public ``` * Method to claim the accrued quantity that the developer has * only teamWallet #### createKlayPool ```solidity function createKlayPool(address token, uint amount, uint fee) public payable ``` * A method called to add a liquidity pair with one side as KLAY * The wallet that calls this must have KSP greater than or equal to createFee * Token for when the KLAY-KIP7 pair to be registered has never been registered before * Parameters * `token` : KIP7 token address to add liquidity * `amount` : the amount of tokens (KIP7) to be provided for the initial liquidity * `fee` : Sets the initial fee value for liquidity pairs * A value between 0 and 100 * Meaning: 0 -> 0%, 100 -> 1% * `msg.value` : KLAY quantity to initially supply liquidity * Delivers the transaction value without specifying otherwise #### createKctPool ```solidity function createKctPool(address tokenA, uint amountA, address tokenB, uint amountB, uint fee) public ``` * Method called to add liquidity pair in case of KIP7 token pair * The wallet calling the KSP above createFee must have it. * parameter * `tokenA` : The address of the first token * `amountA` : The quantity of the first token that supplies the initial liquidity * `tokenB` : The address of the second token * `amountB` : The quantity of the second token that supplies the initial liquidity * `fee` : Sets the initial fee value for liquidity pairs #### exchangeKlayPos ```solidity function exchangeKlayPos(address token, uint amount, address[] memory path) public payable ``` * Method to call when token to be paid is KLAY and a POS transaction is desired * Parameters * `token` : Address of the KIP7 to be recieved * `amount` : the minimum amount tokens that you want to receive * If the amount of tokens to be received is lower than this amount, the Tx will fail. * `path` : list of token addresses to go through for routing transactions * If routing transaction is not needed, submit empty list * `msg.value` : KLAY quantity to be paid #### exchangeKctPos ```solidity function exchangeKctPos(address tokenA, uint amountA, address tokenB, uint amountB, address[] memory path) public ``` * Method called when the token to be paid is KIP7 and a POS transaction is desired * Parameters * `tokenA` : address of token to be paid * `amountA` : the amount of tokens to be paid * `tokenB` : address of token to be received * When KLAY, it is 0x0 * `amountB` : the minimum amount of tokens that you want to receive * If the amount of tokens to be received is lower than this amount, the Tx will fail. * `path` :list of token addresses to go through for routing transactions * If routing transaction is not needed, submit empty list #### exchangeKlayNeg ```solidity function exchangeKlayNeg(address token, uint amount, address[] memory path) public payable ``` * Method for executing a NEG transaction by paying KLAY * Parameters * `token` : address of tokens to be received * `amount` : quantity of tokens to be received * `path` : list of token addresses to go through for routing transactions * If routing transaction is not needed, submit empty list * `msg.value` : maximum amount of payable KLAY * If more KLAY than the corresponding quantity needs to be paid, theTx will fail * the difference with KLAY used in the actual transaction is returned to msg.sender #### exchangeKctNeg ```solidity function exchangeKctNeg(address tokenA, uint amountA, address tokenB, uint amountB, address[] memory path) public ``` * Method for executing NEG transaction by paying KIP7 * Parameters * `tokenA` : address of token to be paid * `amountA` : the maximum amount of tokenA that can be paid * If more tokenA than the corresponding amount is needed, the Tx will fail. * `tokenB` : address of the token to be received * For KLAY: 0x0 * `amountB` : the amount of tokens to be received * `path` : list of token addresses to go through for routing transactions * If routing transaction is not needed, submit empty list {% endtab %} {% endtabs %} --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.klayswap.com/developers/contract/factory.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.