contract KyberNetwork

is Withdrawable, Utils2, KyberNetworkInterface
imports ERC20Interface, KyberReserveInterface, KyberNetworkInterface, Withdrawable, Utils, WhiteListInterface, ExpectedRateInterface, FeeBurnerInterface

Source: KyberNetwork.sol

The KyberNetwork contract's role is to facilitate two main functionalities, which is to return the expected exchange rate, and to execute a trade.

INDEX

TradeInput
BestRateResult
AddReserveToNetwork
EtherReceival
ExpectedRateContractSet
FeeBurnerContractSet
KyberNetworkParamsSet
KyberNetworkSetEnable
KyberProxySet
KyberTrade
ListReservePairs
RemoveReserveFromNetwork
WhiteListContractSet
KyberNetwork
addReserve
enabled
findBestRate
findBestRateOnlyPermission
getExpectedRate
getExpectedRateOnlyPermission
getNumReserves
getReserves
getUserCapInTokenWei
getUserCapInWei
info
listPairForReserve
maxGasPrice
removeReserve
searchBestRate
setEnable
setExpectedRate
setFeeBurner
setInfo
setKyberProxy
setParams
setWhiteList
tradeWithHint

REFERENCE

Structs

`TradeInput`

Property	Type	Description
`trader`	address	trader's address
`src`	ERC20	source ERC20 token contract address
`srcAmount`	uint	source ERC20 token amount in its token decimals
`dest`	ERC20	destination ERC20 token contract address
`destAddress`	address	recipient address for destination ERC20 token
`maxDestAmount`	uint	limit on the amount of destination tokens
`minConversionRate`	uint	minimum conversion rate; trade is canceled if actual rate is lower
`walletId`	address	wallet address to send part of the fees to
`hint`	bytes	internal use by smart contract

`BestRateResult`

Property	Type	Description
`rate`	uint	trader's address
`reserve1`	address	reserve address offering best srcToken -> ETH rate
`reserve2`	address	reserve address offering best ETH -> destToken rate
`weiAmount`	uint	ETH wei amount
`rateSrcToEth`	uint	srcToken -> ETH rate
`rateEthToDest`	uint	ETH -> destToken rate
`destAmount`	uint	destination token amount

Events

`AddReserveToNetwork`

Event for logging reserve additions to the network.

event AddReserveToNetwork(KyberReserveInterface indexed reserve, bool add, bool isPermissionless)

Parameter	Type	Description
`reserve`	KyberReserveInterface	reserve's contract address
`add`	bool	`true` if reserve was successfully added, `false` otherwise
`isPermissionless`	bool	`true` if reserve was permissionlessly added, `false`otherwise

`EtherReceival`

Event for logging amount of ETH received from sender.

event EtherReceival(address indexed sender, uint amount)

Parameter	Type	Description
`sender`	address	sender's address
`amount`	uint	ETH amount sent

`ExpectedRateContractSet`

Event for logging of updates to the ExpectedRate contract address.

event ExpectedRateContractSet(ExpectedRateInterface newContract, ExpectedRateInterface currentContract)

Parameter	Type	Description
`newContract`	ExpectedRateInterface	New ExpectedRate contract address
`currentContract`	ExpectedRateInterface	Current (old) ExpectedRate contract address

`FeeBurnerContractSet`

Event for logging of updates to the FeeBurner contract address.

event FeeBurnerContractSet(FeeBurnerInterface newContract, FeeBurnerInterface currentContract)

Parameter	Type	Description
`newContract`	FeeBurnerInterface	New FeeBurner contract address
`currentContract`	FeeBurnerInterface	Current (old) FeeBurner contract address

`KyberNetworkParamsSet`

Event for logging of updates to the maxGasPrice and negligibleRateDiff parameters

event KyberNetworkParamsSet(uint maxGasPrice, uint negligibleRateDiff)

Parameter	Type	Description
`maxGasPrice`	uint	Maximum gas price limit to prevent frontrunning
`negligibleRateDiff`	uint	Neligible rate difference

`KyberNetworkSetEnable`

Event for logging of enabling or disabling of the network

event KyberNetworkSetEnable(bool isEnabled)

Parameter	Type	Description
`isEnabled`	bool	`true` if network is enabled, `false` if it is disabled

`KyberProxySet`

Event for logging of updates to the KyberNetworkProxy.sol contract address

event KyberProxySet(address proxy, address sender)

Parameter	Type	Description
`proxy`	address	KyberNetworkProxy contract address
`sender`	address	sender's address

`KyberTrade`

Event for logging execution of trades.

event KyberTrade(address indexed trader, ERC20 src, ERC20 dest, uint srcAmount, uint dstAmount, address destAddress, uint ethWeiValue, address reserve1, address reserve2, bytes hint)

Parameter	Type	Description
`trader`	address	trader's address
`src`	ERC20	source ERC20 token contract address
`dest`	ERC20	destination ERC20 token contract address
`srcAmount`	uint	source ERC20 token amount
`dstAmount`	uint	destination ERC20 token amount
`destAddress`	ERC20	recipient address for destination ERC20 token
`ethWeiValue`	uint	Ether wei value of the trade
`reserve1`	address	address of reserve selected for source token to Ether trade
`reserve2`	address	address of reserve selected for source token to Ether trade
`hint`	bytes	Used to determine if permissionless reserves are to be used

`ListReservePairs`

Event for logging of listing of token pairs that a reserve is allowed to trade.

event ListReservePairs(address reserve, ERC20 src, ERC20 dest, bool add)

Parameter	Type	Description
`reserve`	address	reserve's contract address
`src`	ERC20	source ERC20 token contract address
`dest`	ERC20	destination ERC20 token contract address
`add`	bool	`true` if token pair is listed, `false` otherwise

`RemoveReserveFromNetwork`

Event for logging reserve removals from the network.

event RemoveReserveFromNetwork(KyberReserveInterface reserve)

Parameter	Type	Description
`reserve`	KyberReserveInterface	reserve's contract address

`WhiteListContractSet`

Event for logging of updates to the WhiteList contract address.

event WhiteListContractSet(WhiteListInterface newContract, WhiteListInterface currentContract)

Parameter	Type	Description
`newContract`	WhiteListInterface	New whitelist contract address
`currentContract`	WhiteListInterface	Current (old) whitelist contract address

Functions

`KyberNetwork`

Contract constructor. Note that constructor methods are called exactly once during contract instantiation and cannot be called again.

function KyberNetwork(address _admin) public

Parameter	Type	Description
`_admin`	address	admin's wallet address

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const fs = require("fs");
const solc = require("solc");
const Web3 = require("web3");

const web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));
const input = fs.readFileSync("KyberNetwork.sol", "utf8");
const output = await solc.compile(input, 1);
const bytecode = output.contracts["KyberNetwork"].bytecode;
const abi = JSON.parse(output.contracts["KyberNetwork"].interface);

const KyberNetwork = new web3.eth.Contract(JSON.parse(abi));
const _admin = "<ADMIN ADDRESS>";

const deploy = KyberNetwork.deploy({
  data: `0x${bytecode}`,
  arguments: [_admin]
});

broadcastTx(deploy);

Code snippet reference: broadcastTx()

`addReserve`

Adds a reserve to the network. Only an operator can invoke.

function addReserve(KyberReserveInterface reserve, bool isPermissionless) public onlyOperator

Parameter	Type	Description
`reserve`	KyberReserveInterface	reserve's contract address
`isPermissionless`	bool	`true` if added permissionlessly, `false` otherwise

Modifiers: onlyOperator

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const reserve = "0x63825c174ab367968EC60f061753D3bbD36A0D8F";
const isPermissionless = false;

let transactionData = KyberNetwork.methods
  .addReserve(reserve, isPermissionless)
  .encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: OPERATOR_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`enabled`

Determine the state of the network (Eg. disabled when smart contracts are upgraded)

function enabled() public view returns (bool) Returns:
true if network is enabled, false otherwise

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

let networkEnabled = await KyberNetwork.methods.enabled().call();

`findBestRate`

Finds the best conversion rate for a pair of tokens. If several reserves have small rate differences, pick one at random.

function findBestRate(ERC20 src, ERC20 dest, uint srcAmount) public view returns (uint obsolete, uint rate)

Parameter	Type	Description
`src`	ERC20	source ERC20 token contract address
`dest`	ERC20	destination ERC20 token contract address
`srcAmount`	uint	source ERC20 token amount in its token decimals

Returns:
Index of the best reserve (depreciated) and the best exchange rate for the pair

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const src = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; // ETH
const dest = "0xdd974D5C2e2928deA5F71b9825b8b646686BD200"; // KNC
const srcAmount = new web3.utils.BN("3000000000000000000000");
result = await KyberNetwork.methods.findBestRate(src, dest, srcAmount).call();

rate = result[1];

`findBestRateOnlyPermission`

Finds the best conversion rate, using only permissioned reserves, for a pair of tokens. If several reserves have small rate differences, pick one at random.

function findBestRateOnlyPermission(ERC20 src, ERC20 dest, uint srcAmount) public view returns (uint obsolete, uint rate)

Parameter	Type	Description
`src`	ERC20	source ERC20 token contract address
`dest`	ERC20	destination ERC20 token contract address
`srcAmount`	uint	source ERC20 token amount in its token decimals

Returns:
Index of the best reserve (depreciated) and the best exchange rate for the pair

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const src = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; // ETH
const dest = "0xdd974D5C2e2928deA5F71b9825b8b646686BD200"; // KNC
const srcAmount = new web3.utils.BN("3000000000000000000000");
result = await KyberNetwork.methods
  .findBestRateOnlyPermission(src, dest, srcAmount)
  .call();

rate = result[1];

`getExpectedRate`

Get the expected exchange rate.

function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view returns (uint expectedRate, uint slippageRate)

Parameter	Type	Description
`src`	ERC20	source ERC20 token contract address
`dest`	ERC20	destination ERC20 token contract address
`srcQty`	uint	source ERC20 token amount in its token decimals

Returns:
The expected exchange rate and slippage rate

Notes:

Returned values are in precision values (10**18). Refer to the example below.
The Most Significant Bit (MSB) is used for excluding permissionless reserves, since this function lacks a hint parameter for this purpose. Alternatively, call the getExpectedRateOnlyPermission function.

Understanding the returned values

To understand what this rate means, divide the obtained value by 10**18. Let us look at an example. Suppose calling getExpectedRate(KNC_TOKEN,WBTC_TOKEN,1000000000000000000) returns the following values:

expectedRate: 64760000000000
slippageRate: 62817200000000

64760000000000 / (10**18) = 0.0000648098 Hence, 1 KNC token can be converted to 0.000065 WBTC token.

`0` expected and slippage rates

A returned rate of 0 signifies that a trade from the requested source token amount to the destination token is not possible at the moment. It could be due to the following reasons:

No reserve is supporting either src or dest token, or both
No reserve can support the queried srcQty amount (Eg. due to insufficient liquidity, expired conversion rates)
The network is undergoing maintenance (this can be checked with this function)

Turning on MSB to exclude permissionless reserves

Add 2**255 to the desired srcQty. As 2**255 is a really large number, the use of a BigNum library / package is recommended for calculations. Refer to the latter part of the web3 example below.

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const src = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' // ETH
const dest = '0x6b175474e89094c44da98b954eedeac495271d0f' // DAI
const srcQty = new web3.utils.BN('3000000000000000000000')

let result = await kyberNetworkProxyContract.methods.getExpectedRate(
    src,
    dest
    srcQty
).call()

//Example where MSB is turned on to exclude permissionless reserves
const hint = new web3.utils.BN('57896044618658097711785492504343953926634992332820282019729792003956564819968') // 2^255 (turning on MSB)
const newSrcQty = srcQty.add(hint)
let result = await kyberNetworkProxyContract.methods.getExpectedRate(
    src,
    dest
    newSrcQty
).call()

let expectedRate = result[0]
let slippageRate = result[1]

`getExpectedRateOnlyPermission`

Get the expected exchange rate from only permissioned reserves (ie. excluding permissionless reserves).

function getExpectedRateOnlyPermission(ERC20 src, ERC20 dest, uint srcQty) public view returns (uint expectedRate, uint slippageRate)

Parameter	Type	Description
`src`	ERC20	source ERC20 token contract address
`dest`	ERC20	destination ERC20 token contract address
`srcQty`	uint	source ERC20 token amount in its token decimals

Returns:
The expected exchange rate and slippage rate

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const src = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; // ETH
const dest = "0xdd974D5C2e2928deA5F71b9825b8b646686BD200"; // KNC
const srcQty = new web3.utils.BN("3000000000000000000000");

let result = await KyberNetwork.methods
  .getExpectedRateOnlyPermission(src, dest, srcQty)
  .call();

let expectedRate = result[0];
let slippageRate = result[1];

`getNumReserves`

Get the total number of reserves in the network.

function getNumReserves() public view returns (uint)
Returns:
Total number of reserves

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

let numOfReserves = await KyberNetwork.methods.getNumReserves().call();

`getReserves`

Get all the reserves added in the network.

function getReserves() public view returns (KyberReserveInterface[])
Returns:
An array of all reserves' contract addresses

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

let reserves = await KyberNetwork.methods.getReserves().call();

`getUserCapInTokenWei`

Get the user's exchange limit in the specified ERC20 token based on whether user has been KYC'd or not. Future feature.

function getUserCapInTokenWei(address user, ERC20 token) public view returns (uint)

Parameter	Type	Description
`user`	address	user's address
`token`	ERC20	ERC20 token contract address

Returns:
The user's exchange limit in the specified ERC20 token decimals

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const user = account.address;
const token = "0xdd974D5C2e2928deA5F71b9825b8b646686BD200"; // KNC
let userCapInTokenWei = await KyberNetwork.methods
  .getUserCapInTokenWei(user, token)
  .call();

`getUserCapInWei`

Get the user's exchange limit in ETH based on whether user has been KYC'd or not. Currently not enforced.

function getUserCapInWei(address user) public view returns (uint)

Parameter	Type	Description
`user`	address	user's address

Returns:
The user's exchange limit in ETH wei

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const user = account.address;
let userCapInWei = await KyberNetwork.methods.getUserCapInWei(user).call();

`info`

Get the information only used by an external UI application.

function info(bytes32 field) public view returns (uint)

Parameter	Type	Description
`field`	bytes32	key in the `info` mapping

Returns:
Value that was mapped to the field input

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

let value = await KyberNetwork.methods.info(`field`).call();

`listPairForReserve`

Allow or prevent a specific reserve to trade a pair of tokens. Only operator can invoke.

function listPairForReserve(address reserve, ERC20 token, bool ethToToken, bool tokenToEth, bool add) public onlyOperator

Parameter	Type	Description
`reserve`	KyberReserveInterface	reserve's contract address
`token`	ERC20	Token contract address
`ethToToken`	bool	`true` if ETH -> token trade supported, `false` otherwise
`tokenToEth`	bool	`true` if token -> ETH trade supported, `false` otherwise
`add`	uint	`true` if trade enabled, otherwise disable trade if `false`

Modifiers: onlyOperator

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const reserve = "0x798AbDA6Cc246D0EDbA912092A2a3dBd3d11191B";
const token = "0xdd974D5C2e2928deA5F71b9825b8b646686BD200"; // KNC
const ethToToken = true;
const tokenToEth = false;
const add = true;

let transactionData = KyberNetwork.methods
  .listPairForReserve(reserve, token, ethToToken, tokenToEth, add)
  .encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: ADMIN_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`maxGasPrice`

Get the maximum gas price allowable for trade transactions.

function maxGasPrice() public view returns (uint)
Returns:
Maximum gas price

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

let maxGasPrice = await KyberNetwork.methods.maxGasPrice().call();

`removeReserve`

Removes a reserve from the network. Only an operator can invoke.

function removeReserve(KyberReserveInterface reserve, uint index) public onlyOperator

Parameter	Type	Description
`reserve`	KyberReserveInterface	reserve's contract address
`index`	uint	Reserve index in the reserve array

Modifiers: onlyOperator

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const reserve = "0x63825c174ab367968EC60f061753D3bbD36A0D8F";
var allReserves = await KyberNetworkContract.methods.getReserves().call();
const reserveIndex = allReserves.indexOf(reserve);

let transactionData = KyberNetwork.methods
  .removeReserve(reserve, reserveIndex)
  .encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: OPERATOR_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`searchBestRate`

Obtain the best exchange rate.
Note: either src or dest must be ETH, ie. srcToken -> ETH or ETH -> destToken.

function searchBestRate(ERC20 src, ERC20 dest, uint srcAmount) public view returns (address, uint)

Parameter	Type	Description
`src`	ERC20	source token contract address
`dest`	ERC20	destination token contract address
`srcAmount`	uint	source ERC20 token amount in its token decimals

Returns:
Reserve address that offered the best rate, and the actual exchange rate.

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

src = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; // ETH
dest = "0xdd974D5C2e2928deA5F71b9825b8b646686BD200"; // KNC
srcAmount = new web3.utils.BN("3000000000000000000000");

let result = await KyberNetwork.methods
  .searchBestRate(src, dest, srcAmount)
  .call();
reserveAddress = result[0];
rate = result[1];

`setEnable`

Enables or disables the entire network (Eg. disabled when smart contracts are upgraded)

function setEnable(bool _enable) public onlyAdmin

Parameter	Type	Description
`_enable`	bool	`true` to enable network, `false` to disable

Modifiers: onlyAdmin

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const _enable = true;
let transactionData = KyberNetwork.methods.setEnable(_enable).encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: ADMIN_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`setExpectedRate`

Set whiteList contract address. Only admin can invoke.

function setExpectedRate(ExpectedRateInterface expectedRate) public onlyAdmin

Parameter	Type	Description
`expectedRate`	ExpectedRateInterface	ExpectedRate contract address

Modifiers: onlyAdmin

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const expectedRate = "0x543f2592b1C478837B5EE2013eD26C7Fe04a8C7e";
let transactionData = KyberNetwork.methods
  .setExpectedRate(expectedRate)
  .encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: ADMIN_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`setFeeBurner`

Set feeBurner contract address. Only admin can invoke.

function setFeeBurner(FeeBurnerInterface feeBurner) public onlyAdmin

Parameter	Type	Description
`feeBurner`	FeeBurnerInterface	FeeBurner contract address

Modifiers: onlyAdmin

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const feeBurner = "0x543f2592b1C478837B5EE2013eD26C7Fe04a8C7e";
let transactionData = KyberNetwork.methods.setFeeBurner(feeBurner).encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: ADMIN_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`setInfo`

Sets the information only used by an external UI application.

function setInfo(bytes32 field, uint value) public onlyOperator

Parameter	Type	Description
`field`	bytes32	key in the `info` mapping
`value`	uint	value to be set in the `info` field

Modifiers: onlyOperator

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const field = "someField";
const value = "someValue";
let transactionData = KyberNetwork.methods.setInfo(field, value).encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: OPERATOR_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`setKyberProxy`

Sets the KyberNetworkProxy.sol contract address.

function setKyberProxy(address networkProxy) public onlyAdmin

Parameter	Type	Description
`networkProxy`	address	KyberNetworkProxy contract address

Modifiers: onlyAdmin

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const networkProxy = "0x818E6FECD516Ecc3849DAf6845e3EC868087B755";
let transactionData = KyberNetwork.methods
  .setKyberProxy(networkProxy)
  .encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: ADMIN_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`setParams`

Sets the parameters for maxGasPrice and negligibleRateDiff. Only admin can invoke.

function setParams(uint _maxGasPrice, uint _negligibleRateDiff) public onlyAdmin

Parameter	Type	Description
`_maxGasPrice`	uint	maximum gas price for trades
`_negligibleRateDiff`	uint	Neligible rate difference

Modifiers: onlyAdmin

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const _maxGasPrice = new web3.utils.BN("50000000000");
const _negligibleRateDiff = new web3.utils.BN("350000000");

let transactionData = KyberNetwork.methods
  .setParams(_maxGasPrice, _negligibleRateDiff)
  .encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: ADMIN_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`setWhiteList`

Set whiteList contract address. Only admin can invoke.

function setWhiteList(WhiteListInterface whiteList) public onlyAdmin

Parameter	Type	Description
`whiteList`	WhiteListInterface	WhiteList contract address

Modifiers: onlyAdmin

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const whiteList = "0x543f2592b1C478837B5EE2013eD26C7Fe04a8C7e";
let transactionData = KyberNetwork.methods.setWhiteList(whiteList).encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: ADMIN_ADDRESS,
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

`tradeWithHint`

Makes a trade between src and dest token and send dest tokens to destAddress, with an additional hint parameter for exclusion of permissionless reserves.

function tradeWithHint(address trader, ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId, bytes hint) public nonReentrant payable returns (uint)

Parameter	Type	Description
`trader`	address	trader's address
`src`	ERC20	source ERC20 token contract address
`srcAmount`	uint	source ERC20 token amount in its token decimals
`dest`	ERC20	destination ERC20 token contract address
`destAddress`	address	recipient address for destination ERC20 token
`maxDestAmount`	uint	limit on the amount of destination tokens
`minConversionRate`	uint	minimum conversion rate; trade is canceled if actual rate is lower
`walletId`	address	wallet address to send part of the fees to
`hint`	bytes	for filtering permissionless reserves

Returns:
Amount of actual destination tokens

Notes:

`srcAmount` | `maxDestAmount`

These amounts should be in the source and destination token decimals respectively. For example, if the user wants to swap from / to 10 POWR, which has 6 decimals, it would be 10 * (10 ** 6) = 10000000

`maxDestAmount`

This parameter should never be zero. Set to an arbitarily large amount for all source tokens to be converted. When using maxDestAmount, we recommend using slippageRate or add a buffer to expectedRate rather than using the exact rate from getExpectedRate. Otherwise, it is likely that the trade will revert.

`minConversionRate`

This rate is independent of the source and destination token decimals. To calculate this rate, take yourRate * 10**18. For example, even though WBTC has 8 token decimals, if we want the minimum conversion rate to be 1 ETH = 0.023 WBTC, then minConversionRate = 0.023 * (10 ** 18).

`walletId`

If you are part of our fee sharing program, this will be your registered wallet address. Set to the null address if you are not a participant.

`hint`

By default, permissionless reserves are included for selection for the trade. To exclude permissionless reserves, parse PERM in the hint parameter.

Web3 Example:

// DISCLAIMER: Code snippets in this guide are just examples and you
// should always do your own testing. If you have questions, visit our
// https://t.me/KyberDeveloper.

const src = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; // ETH
const srcAmount = new web3.utils.BN("3000000000000000000000");
const dest = "0xdd974D5C2e2928deA5F71b9825b8b646686BD200"; // KNC
const destAddress = "RECIPIENT_ADDRESS";
const maxDestAmount = new web3.utils.BN(Math.pow(2, 255).toString);
const minConversionRate = new web3.utils.BN("55555");
const walletId = "0x0000000000000000000000000000000000000000";
const hint = ""; //hint = "PERM" to filter permissionless reserves

transactionData = KyberNetwork.methods
  .trade(
    src,
    srcAmount,
    dest,
    destAddress,
    maxDestAmount,
    minConversionRate,
    walletId,
    hint
  )
  .encodeABI();

txReceipt = await web3.eth.sendTransaction({
  from: USER_WALLET_ADDRESS, //obtained from web3 interface
  to: KYBER_NETWORK_ADDRESS,
  data: transactionData
});

contract KyberNetwork

INDEX

REFERENCE

Structs

TradeInput

BestRateResult

Events

AddReserveToNetwork

EtherReceival

ExpectedRateContractSet

FeeBurnerContractSet

KyberNetworkParamsSet

KyberNetworkSetEnable

KyberProxySet

KyberTrade

ListReservePairs

RemoveReserveFromNetwork

WhiteListContractSet

Functions

KyberNetwork

addReserve

enabled

findBestRate

findBestRateOnlyPermission

getExpectedRate

Understanding the returned values

0 expected and slippage rates

Turning on MSB to exclude permissionless reserves

getExpectedRateOnlyPermission

getNumReserves

getReserves

getUserCapInTokenWei

getUserCapInWei

info

listPairForReserve

maxGasPrice

removeReserve

searchBestRate

setEnable

setExpectedRate

setFeeBurner

setInfo

setKyberProxy

setParams

setWhiteList

tradeWithHint

srcAmount | maxDestAmount

maxDestAmount

minConversionRate

walletId

hint

`TradeInput`

`BestRateResult`

`AddReserveToNetwork`

`EtherReceival`

`ExpectedRateContractSet`

`FeeBurnerContractSet`

`KyberNetworkParamsSet`

`KyberNetworkSetEnable`

`KyberProxySet`

`KyberTrade`

`ListReservePairs`

`RemoveReserveFromNetwork`

`WhiteListContractSet`

`KyberNetwork`

`addReserve`

`enabled`

`findBestRate`

`findBestRateOnlyPermission`

`getExpectedRate`

`0` expected and slippage rates

`getExpectedRateOnlyPermission`

`getNumReserves`

`getReserves`

`getUserCapInTokenWei`

`getUserCapInWei`

`info`

`listPairForReserve`

`maxGasPrice`

`removeReserve`

`searchBestRate`

`setEnable`

`setExpectedRate`

`setFeeBurner`

`setInfo`

`setKyberProxy`

`setParams`

`setWhiteList`

`tradeWithHint`

`srcAmount` | `maxDestAmount`

`maxDestAmount`

`minConversionRate`

`walletId`

`hint`