KLAYswap
Search…
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

Contract adress after production is deployed (scope link)

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

Events
Read-Only Functions
State-Changing Functions

Events

Transfer

1
event Transfer(address indexed from, address indexed to, uint amount);
Copied!
  • Event for the movement and burning of KSP tokens

Approval

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

ChangeCreateFee

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

ChangeTeamWallet

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

ClaimTeamAward

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

ChangeNextOwner

1
event ChangeNextOwner(address nextOwner);
Copied!
  • Event to pre-register new owner
  • owner will be governance smart contract (In Intial period before KSP distributed, DEV team have owner permission)

ChangeOwner

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

CreatePool

1
event CreatePool(address tokenA, uint amountA, address tokenB, uint amountB, uint fee, address exchange, uint exid);
Copied!
  • 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

1
event ExchangePos(address tokenA, uint amountA, address tokenB, uint amountB);
Copied!
  • 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

1
event ExchangeNeg(address tokenA, uint amountA, address tokenB, uint amountB);
Copied!
  • 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

  • tokenA, tokenB 두 토큰의 address를 입력시 해당 페어에 해당하는 contract address를 조회 가능
  • 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

1
function mined() public view returns (uint)
Copied!
  • 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

1
function estimatePos(address inToken, uint inAmount, address outToken) private view returns (uint)
Copied!
  • 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
1
function estimateNeg(address inToken, address outToken, uint outAmount) private view returns (uint)
Copied!
  • 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

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

getPoolAddress

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

State-Changing Functions

transfer

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

transferFrom

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

approve

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

changeNextOwner

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

changeOwner

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

changeCreateFee

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

changeTeamWallet

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

changePoolFee

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

changeMiningRate

1
function changeMiningRate(address[] memory tokenA, address[] memory tokenB, uint[] memory rate) public
Copied!
  • 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

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

createKlayPool

1
function createKlayPool(address token, uint amount, uint fee) public payable
Copied!
  • 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

1
function createKctPool(address tokenA, uint amountA, address tokenB, uint amountB, uint fee) public
Copied!
  • 양쪽 다 KIP7인 경우의 유동성 페어 추가를 위해 호출하는 method
  • createFee 이상의 KSP를 호출하는 지갑이 보유하고 있어야 함
  • 등록하려는 KIP7-KIP7 페어가 한번도 등록되지 않은 토큰 페어여야 함
  • 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

1
function exchangeKlayPos(address token, uint amount, address[] memory path) public payable
Copied!
  • 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

1
function exchangeKctPos(address tokenA, uint amountA, address tokenB, uint amountB, address[] memory path) public
Copied!
  • 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

1
function exchangeKlayNeg(address token, uint amount, address[] memory path) public payable
Copied!
  • 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

1
function exchangeKctNeg(address tokenA, uint amountA, address tokenB, uint amountB, address[] memory path) public
Copied!
  • 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
Last modified 1yr ago