# 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 %}