KLAYswap
English
Search…
⌃K

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

Events, Read-Only Functions, and State-Changing Functions

Events
Read-Only Functions
State-Changing Functions

Events

Transfer

event Transfer(address indexed from, address indexed to, uint amount);
  • Event for the movement and burning of KSP tokens
  • A KIP7 Standard Event

Approval

event Approval(address indexed holder, address indexed spender, uint amount);

ChangeCreateFee

event ChangeCreateFee(uint _createFee);
  • An event to change the Pool Contract Creation Fee when adding a new liquidity pool pair

ChangeTeamWallet

event ChangeTeamWallet(address _teamWallet);
  • Event to change the development team wallet

ClaimTeamAward

event ClaimTeamAward(uint award, uint totalAward);
  • Event to claim the development and stabilization commission

ChangeNextOwner

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

event ChangeOwner(address owner);
  • Event that completes changing the owner

CreatePool

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

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

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

​

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

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

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
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

function getPoolCount() public view returns (uint)
  • Returns the current number of registered liquidity pools.

getPoolAddress

function getPoolAddress(uint idx) public view returns (address)
  • Returns the liquidity pair contract address of the pair's index.
​

​

State-Changing Functions

transfer

function transfer(address _to, uint _value) public returns (bool)
  • KIP7 Standard
  • Method to transfer KSP tokens

transferFrom

function transferFrom(address _from, address _to, uint _value) public returns (bool)
  • KIP7 Standard
  • Method to transfer tokens on behalf of the approved wallet

approve

function approve(address _spender, uint _value) public returns (bool)
  • KIP7 Standard
  • Method to approve a transfer as much as value to spender

changeNextOwner

function changeNextOwner(address _nextOwner) public
  • Method to set the next Owner in advance before changing Owner
  • only owner

changeOwner

function changeOwner() public
  • Method for the next Owner to change the actual Owner
  • only nextOwner

changeCreateFee

function changeCreateFee(uint _createFee) public
  • Method that changes KSP fees when liquidity pairs are added
  • only Owner

changeTeamWallet

function changeTeamWallet(address _teamWallet) public
  • Method to change the developer wallet
  • only owner

changePoolFee

function changePoolFee(address tokenA, address tokenB, uint fee) public
  • Method to change transaction fees for each liquidity pair
  • only owner

changeMiningRate

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

function claimTeamAward() public
  • Method to claim the accrued quantity that the developer has
  • only teamWallet

createKlayPool

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

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

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

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

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

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
DEVELOPERS - Previous
Contract
Next
Exchange
Last modified 9mo ago