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 11mo ago