poanetwork
/
tokenbridge-contracts
mirror of https://github.com/poanetwork/tokenbridge-contracts.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Refactor fee into homeFee and foreignFee

This commit is contained in:
Gerardo Nardelli 2019-02-01 17:06:19 -03:00
parent 1931586d2f
commit e1787e6309
9 changed files with 171 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
contracts/upgradeable_contracts/BaseFeeManager.sol
View File

@ -3,19 +3,21 @@ pragma solidity 0.4.24;
import "../upgradeability/EternalStorage.sol";
import "../libraries/SafeMath.sol";
import "../IRewardableValidators.sol";
import "./FeeTypes.sol";
contract BaseFeeManager is EternalStorage {
contract BaseFeeManager is EternalStorage, FeeTypes {
using SafeMath for uint256;
bytes32 public constant REWARD_FOR_TRANSFERRING_FROM_HOME = keccak256(abi.encodePacked("reward-transferring-from-home"));
bytes32 public constant REWARD_FOR_TRANSFERRING_FROM_FOREIGN = keccak256(abi.encodePacked("reward-transferring-from-foreign"));
event FeeUpdated(uint256 fee);
event HomeFeeUpdated(uint256 fee);
event ForeignFeeUpdated(uint256 fee);
function calculateFee(uint256 _value, bool _recover) external view returns(uint256) {
uint256 fee = getFee();
function calculateFee(uint256 _value, bool _recover, bytes32 _feeType) external view returns(uint256) {
uint256 fee = _feeType == HOME_FEE ? getHomeFee() : getForeignFee();
uint256 eth = 1 ether;
if (!_recover) {
return _value.mul(fee).div(eth);
@ -23,13 +25,22 @@ contract BaseFeeManager is EternalStorage {
return _value.mul(fee).div(eth.sub(fee));
}
function setFee(uint256 _fee) external {
uintStorage[keccak256(abi.encodePacked("fee"))] = _fee;
emit FeeUpdated(_fee);
function setHomeFee(uint256 _fee) external {
uintStorage[keccak256(abi.encodePacked("homeFee"))] = _fee;
emit HomeFeeUpdated(_fee);
}
function getFee() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("fee"))];
function getHomeFee() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("homeFee"))];
}
function setForeignFee(uint256 _fee) external {
uintStorage[keccak256(abi.encodePacked("foreignFee"))] = _fee;
emit ForeignFeeUpdated(_fee);
}
function getForeignFee() public view returns(uint256) {
return uintStorage[keccak256(abi.encodePacked("foreignFee"))];
}
function distributeFeeFromAffirmation(uint256 _fee) external {

7
contracts/upgradeable_contracts/FeeTypes.sol Normal file
View File

@ -0,0 +1,7 @@
pragma solidity 0.4.24;
contract FeeTypes {
bytes32 internal constant HOME_FEE = keccak256(abi.encodePacked("home-fee"));
bytes32 internal constant FOREIGN_FEE = keccak256(abi.encodePacked("foreign-fee"));
}

34
contracts/upgradeable_contracts/RewardableBridge.sol
View File

@ -1,18 +1,33 @@
pragma solidity 0.4.24;
import "./Ownable.sol";
import "./FeeTypes.sol";
contract RewardableBridge is Ownable {
contract RewardableBridge is Ownable, FeeTypes {
function setFee(uint256 _fee) external onlyOwner {
_setFee(feeManagerContract(), _fee);
function setHomeFee(uint256 _fee) external onlyOwner {
_setFee(feeManagerContract(), _fee, HOME_FEE);
}
function getFee() public view returns(uint256) {
function setForeignFee(uint256 _fee) external onlyOwner {
_setFee(feeManagerContract(), _fee, FOREIGN_FEE);
}
function getHomeFee() public view returns(uint256) {
return _getFee(HOME_FEE);
}
function getForeignFee() public view returns(uint256) {
return _getFee(FOREIGN_FEE);
}
function _getFee(bytes32 _feeType) public view returns(uint256) {
uint256 fee;
bytes memory callData = abi.encodeWithSignature("getFee()");
address feeManager = feeManagerContract();
string memory method = _feeType == HOME_FEE ? "getHomeFee()" : "getForeignFee()";
bytes memory callData = abi.encodeWithSignature(method);
assembly {
let result := callcode(gas, feeManager, 0x0, add(callData, 0x20), mload(callData), 0, 32)
fee := mload(0)
@ -46,8 +61,9 @@ contract RewardableBridge is Ownable {
addressStorage[keccak256(abi.encodePacked("feeManagerContract"))] = _feeManager;
}
function _setFee(address _feeManager, uint256 _fee) internal {
require(_feeManager.delegatecall(abi.encodeWithSignature("setFee(uint256)", _fee)));
function _setFee(address _feeManager, uint256 _fee, bytes32 _feeType) internal {
string memory method = _feeType == HOME_FEE ? "setHomeFee(uint256)" : "setForeignFee(uint256)";
require(_feeManager.delegatecall(abi.encodeWithSignature(method, _fee)));
}
function isContract(address _addr) internal view returns (bool)
@ -57,9 +73,9 @@ contract RewardableBridge is Ownable {
return length > 0;
}
function calculateFee(uint256 _value, bool _recover, address _impl) internal view returns(uint256) {
function calculateFee(uint256 _value, bool _recover, address _impl, bytes32 _feeType) internal view returns(uint256) {
uint256 fee;
bytes memory callData = abi.encodeWithSignature("calculateFee(uint256,bool)", _value, _recover);
bytes memory callData = abi.encodeWithSignature("calculateFee(uint256,bool,bytes32)", _value, _recover, _feeType);
assembly {
let result := callcode(gas, _impl, 0x0, add(callData, 0x20), mload(callData), 0, 32)
fee := mload(0)

12
contracts/upgradeable_contracts/erc20_to_native/HomeBridgeErcToNative.sol
View File

@ -26,7 +26,7 @@ contract HomeBridgeErcToNative is EternalStorage, BasicBridge, BasicHomeBridge,
uint256 valueToTransfer = msg.value;
address feeManager = feeManagerContract();
if (feeManager != address(0)) {
uint256 fee = calculateFee(valueToTransfer, false, feeManager);
uint256 fee = calculateFee(valueToTransfer, false, feeManager, HOME_FEE);
valueToTransfer = valueToTransfer.sub(fee);
}
setTotalBurntCoins(totalBurntCoins().add(valueToTransfer));
@ -76,7 +76,8 @@ contract HomeBridgeErcToNative is EternalStorage, BasicBridge, BasicHomeBridge,
uint256 _foreignMaxPerTx,
address _owner,
address _feeManager,
uint256 _fee
uint256 _homeFee,
uint256 _foreignFee
) public returns(bool)
{
_initialize(
@ -93,7 +94,8 @@ contract HomeBridgeErcToNative is EternalStorage, BasicBridge, BasicHomeBridge,
);
require(isContract(_feeManager));
addressStorage[keccak256(abi.encodePacked("feeManagerContract"))] = _feeManager;
_setFee(_feeManager, _fee);
_setFee(_feeManager, _homeFee, HOME_FEE);
_setFee(_feeManager, _foreignFee, FOREIGN_FEE);
setInitialize(true);
return isInitialized();
@ -157,7 +159,7 @@ contract HomeBridgeErcToNative is EternalStorage, BasicBridge, BasicHomeBridge,
address feeManager = feeManagerContract();
if (feeManager != address(0)) {
uint256 fee = calculateFee(valueToMint, false, feeManager);
uint256 fee = calculateFee(valueToMint, false, feeManager, FOREIGN_FEE);
distributeFeeFromAffirmation(fee, feeManager);
valueToMint = valueToMint.sub(fee);
}
@ -173,7 +175,7 @@ contract HomeBridgeErcToNative is EternalStorage, BasicBridge, BasicHomeBridge,
bytes32 txHash;
address contractAddress;
(recipient, amount, txHash, contractAddress) = Message.parseMessage(_message);
uint256 fee = calculateFee(amount, true, feeManager);
uint256 fee = calculateFee(amount, true, feeManager, HOME_FEE);
distributeFeeFromSignatures(fee, feeManager);
}
}

8
contracts/upgradeable_contracts/native_to_erc20/ForeignBridgeNativeToErc.sol
View File

@ -54,7 +54,8 @@ contract ForeignBridgeNativeToErc is ERC677Receiver, BasicBridge, BasicForeignBr
uint256 _homeMaxPerTx,
address _owner,
address _feeManager,
uint256 _fee
uint256 _homeFee,
uint256 _foreignFee
) public returns(bool) {
_initialize(
_validatorContract,
@ -70,7 +71,8 @@ contract ForeignBridgeNativeToErc is ERC677Receiver, BasicBridge, BasicForeignBr
);
require(isContract(_feeManager));
addressStorage[keccak256(abi.encodePacked("feeManagerContract"))] = _feeManager;
_setFee(_feeManager, _fee);
_setFee(_feeManager, _homeFee, HOME_FEE);
_setFee(_feeManager, _foreignFee, FOREIGN_FEE);
setInitialize(true);
return isInitialized();
}
@ -119,7 +121,7 @@ contract ForeignBridgeNativeToErc is ERC677Receiver, BasicBridge, BasicForeignBr
uint256 valueToMint = _amount;
address feeManager = feeManagerContract();
if (feeManager != address(0)) {
uint256 fee = calculateFee(valueToMint, false, feeManager);
uint256 fee = calculateFee(valueToMint, false, feeManager, HOME_FEE);
distributeFeeFromSignatures(fee, feeManager);
valueToMint = valueToMint.sub(fee);
}

8
contracts/upgradeable_contracts/native_to_erc20/HomeBridgeNativeToErc.sol
View File

@ -56,7 +56,8 @@ contract HomeBridgeNativeToErc is EternalStorage, BasicBridge, BasicHomeBridge,
uint256 _foreignMaxPerTx,
address _owner,
address _feeManager,
uint256 _fee
uint256 _homeFee,
uint256 _foreignFee
) public returns(bool)
{
_initialize(
@ -72,7 +73,8 @@ contract HomeBridgeNativeToErc is EternalStorage, BasicBridge, BasicHomeBridge,
);
require(isContract(_feeManager));
addressStorage[keccak256(abi.encodePacked("feeManagerContract"))] = _feeManager;
_setFee(_feeManager, _fee);
_setFee(_feeManager, _homeFee, HOME_FEE);
_setFee(_feeManager, _foreignFee, FOREIGN_FEE);
setInitialize(true);
return isInitialized();
}
@ -118,7 +120,7 @@ contract HomeBridgeNativeToErc is EternalStorage, BasicBridge, BasicHomeBridge,
address feeManager = feeManagerContract();
if (feeManager != address(0)) {
uint256 fee = calculateFee(valueToTransfer, false, feeManager);
uint256 fee = calculateFee(valueToTransfer, false, feeManager, FOREIGN_FEE);
distributeFeeFromAffirmation(fee, feeManager);
valueToTransfer = valueToTransfer.sub(fee);
}

73
test/erc_to_native/home_bridge.test.js
View File

@ -147,11 +147,12 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
})
describe('#rewardableInitialize', async() => {
let feeManager, fee
let feeManager, homeFee, foreignFee
beforeEach(async () => {
feeManager = await FeeManagerErcToNative.new()
homeContract = await HomeBridge.new()
fee = web3.toBigNumber(web3.toWei(0.001, "ether"))
homeFee = web3.toBigNumber(web3.toWei(0.001, "ether"))
foreignFee = web3.toBigNumber(web3.toWei(0.002, "ether"))
})
it('sets variables', async () => {
ZERO_ADDRESS.should.be.equal(await homeContract.validatorContract())
@ -161,7 +162,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
false.should.be.equal(await homeContract.isInitialized())
ZERO_ADDRESS.should.be.equal(await homeContract.blockRewardContract())
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled
true.should.be.equal(await homeContract.isInitialized())
validatorContract.address.should.be.equal(await homeContract.validatorContract())
@ -182,24 +183,26 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feeManagerContract = await homeContract.feeManagerContract()
feeManagerContract.should.be.equals(feeManager.address)
const bridgeFee = await homeContract.getFee()
bridgeFee.should.be.bignumber.equal(fee)
const bridgeHomeFee = await homeContract.getHomeFee()
bridgeHomeFee.should.be.bignumber.equal(homeFee)
const bridgeForeignFee = await homeContract.getForeignFee()
bridgeForeignFee.should.be.bignumber.equal(foreignFee)
})
it('cant initialize with invalid arguments', async () => {
false.should.be.equal(await homeContract.isInitialized())
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, 0, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(owner, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(ZERO_ADDRESS, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, owner, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, halfEther, oneEther, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, ZERO_ADDRESS, fee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, 0, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(owner, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(ZERO_ADDRESS, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, owner, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, halfEther, oneEther, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, ZERO_ADDRESS, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
true.should.be.equal(await homeContract.isInitialized())
})
it('can update fee contract', async () => {
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
// Given
const newFeeManager = await FeeManagerErcToNative.new()
@ -213,17 +216,21 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
})
it('can update fee', async () => {
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await homeContract.rewardableInitialize(validatorContract.address, '3', '2', '1', gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
// Given
const newFee = web3.toBigNumber(web3.toWei(0.1, "ether"))
const newHomeFee = web3.toBigNumber(web3.toWei(0.1, "ether"))
const newForeignFee = web3.toBigNumber(web3.toWei(0.2, "ether"))
// When
await homeContract.setFee(newFee, { from: owner }).should.be.fulfilled
await homeContract.setHomeFee(newHomeFee, { from: owner }).should.be.fulfilled
await homeContract.setForeignFee(newForeignFee, { from: owner }).should.be.fulfilled
// Then
const bridgeFee = await homeContract.getFee()
bridgeFee.should.be.bignumber.equal(newFee)
const bridgeHomeFee = await homeContract.getHomeFee()
bridgeHomeFee.should.be.bignumber.equal(newHomeFee)
const bridgeForeignFee = await homeContract.getForeignFee()
bridgeForeignFee.should.be.bignumber.equal(newForeignFee)
})
})
@ -903,19 +910,23 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feeManagerContract = await homeBridge.feeManagerContract()
feeManagerContract.should.be.equals(feeManager.address)
})
it('should be able to set and get fee', async () => {
it('should be able to set and get fees', async () => {
// Given
// 10% fee
const fee = web3.toBigNumber(web3.toWei(0.1, "ether"))
const homeFee = web3.toBigNumber(web3.toWei(0.1, "ether"))
const foreignFee = web3.toBigNumber(web3.toWei(0.2, "ether"))
const feeManager = await FeeManagerErcToNative.new()
await homeBridge.setFeeManagerContract(feeManager.address, { from: owner }).should.be.fulfilled
// When
await homeBridge.setFee(fee, { from: owner }).should.be.fulfilled
await homeBridge.setHomeFee(homeFee, { from: owner }).should.be.fulfilled
await homeBridge.setForeignFee(foreignFee, { from: owner }).should.be.fulfilled
// Then
const bridgeFee = await homeBridge.getFee()
bridgeFee.should.be.bignumber.equal(fee)
const bridgeHomeFee = await homeBridge.getHomeFee()
bridgeHomeFee.should.be.bignumber.equal(homeFee)
const bridgeForeignFee = await homeBridge.getForeignFee()
bridgeForeignFee.should.be.bignumber.equal(foreignFee)
})
it('should be able to get fee manager mode', async () => {
// Given
@ -955,7 +966,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeManager = await FeeManagerErcToNative.new()
await homeBridge.setFeeManagerContract(feeManager.address, { from: owner }).should.be.fulfilled
await homeBridge.setFee(feeInWei, { from: owner }).should.be.fulfilled
await homeBridge.setForeignFee(feeInWei, { from: owner }).should.be.fulfilled
const recipient = accounts[5];
const value = halfEther;
@ -1016,7 +1027,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feePerValidatorPlusDiff = web3.toBigNumber(166666666666668)
const feeManager = await FeeManagerErcToNative.new()
await homeBridge.setFeeManagerContract(feeManager.address, { from: owner }).should.be.fulfilled
await homeBridge.setFee(feeInWei, { from: owner }).should.be.fulfilled
await homeBridge.setForeignFee(feeInWei, { from: owner }).should.be.fulfilled
const recipient = accounts[8];
const balanceBefore = await web3.eth.getBalance(recipient)
@ -1093,7 +1104,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feePerValidator = feeAmount.div(web3.toBigNumber(5))
const feeManager = await FeeManagerErcToNative.new()
await homeBridge.setFeeManagerContract(feeManager.address, { from: owner }).should.be.fulfilled
await homeBridge.setFee(feeInWei, { from: owner }).should.be.fulfilled
await homeBridge.setForeignFee(feeInWei, { from: owner }).should.be.fulfilled
const recipient = "0xf4bef13f9f4f2b203faf0c3cbbaabe1afe056955";
const balanceBefore = await web3.eth.getBalance(recipient)
@ -1170,7 +1181,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeManager = await FeeManagerErcToNative.new()
await homeBridge.setFeeManagerContract(feeManager.address, { from: owner }).should.be.fulfilled
await homeBridge.setFee(feeInWei, { from: owner }).should.be.fulfilled
await homeBridge.setHomeFee(feeInWei, { from: owner }).should.be.fulfilled
// When
const { logs } = await homeBridge.sendTransaction({ from: recipient, value }).should.be.fulfilled
@ -1208,7 +1219,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeManager = await FeeManagerErcToNative.new()
await homeBridge.setFeeManagerContract(feeManager.address, { from: owner }).should.be.fulfilled
await homeBridge.setFee(feeInWei, { from: owner }).should.be.fulfilled
await homeBridge.setHomeFee(feeInWei, { from: owner }).should.be.fulfilled
const recipient = accounts[5];
const initialValue = halfEther
@ -1265,7 +1276,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feePerValidator = web3.toBigNumber(166666666666666)
const feePerValidatorPlusDiff = web3.toBigNumber(166666666666668)
await homeBridge.setFeeManagerContract(feeManager.address, { from: owner }).should.be.fulfilled
await homeBridge.setFee(feeInWei, { from: owner }).should.be.fulfilled
await homeBridge.setHomeFee(feeInWei, { from: owner }).should.be.fulfilled
const recipient = accounts[7];
const initialValue = halfEther
@ -1338,7 +1349,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeManager = await FeeManagerErcToNative.new()
await homeBridge.setFeeManagerContract(feeManager.address, { from: owner }).should.be.fulfilled
await homeBridge.setFee(feeInWei, { from: owner }).should.be.fulfilled
await homeBridge.setHomeFee(feeInWei, { from: owner }).should.be.fulfilled
const recipient = accounts[0];
const initialValue = halfEther
@ -1400,7 +1411,7 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
for (let i = 0; i < 10; i++) {
// send Tx to generate new blocks
await feeManager.setFee(0).should.be.fulfilled
await feeManager.setHomeFee(0).should.be.fulfilled
// When
const result = await feeManager.random(3);

52
test/native_to_erc/foreign_bridge_test.js
View File

@ -514,7 +514,7 @@ contract('ForeignBridge', async (accounts) => {
})
describe('#rewardableInitialize', async() => {
let fee, foreignBridge, token, rewardableValidators
let homeFee, foreignFee, foreignBridge, token, rewardableValidators
let validators = [accounts[1]]
let rewards = [accounts[2]]
let requiredSignatures = 1
@ -523,7 +523,8 @@ contract('ForeignBridge', async (accounts) => {
rewardableValidators = await RewardableValidators.new()
await rewardableValidators.initialize(requiredSignatures, validators, rewards, owner).should.be.fulfilled
foreignBridge = await ForeignBridge.new()
fee = web3.toBigNumber(web3.toWei(0.001, "ether"))
homeFee = web3.toBigNumber(web3.toWei(0.001, "ether"))
foreignFee = web3.toBigNumber(web3.toWei(0.002, "ether"))
})
it('sets variables', async () => {
const feeManager = await FeeManagerNativeToErc.new()
@ -533,13 +534,13 @@ contract('ForeignBridge', async (accounts) => {
'0'.should.be.bignumber.equal(await foreignBridge.maxPerTx())
false.should.be.equal(await foreignBridge.isInitialized())
await foreignBridge.rewardableInitialize(ZERO_ADDRESS, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, ZERO_ADDRESS, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, 0, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(owner, token.address, oneEther, halfEther, minPerTx, requireBlockConfirmations, gasPrice, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, owner, oneEther, halfEther, minPerTx, requireBlockConfirmations, gasPrice, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, owner, oneEther, halfEther, minPerTx, requireBlockConfirmations, gasPrice, homeDailyLimit, homeMaxPerTx, owner, ZERO_ADDRESS, fee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await foreignBridge.rewardableInitialize(ZERO_ADDRESS, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, ZERO_ADDRESS, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, 0, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(owner, token.address, oneEther, halfEther, minPerTx, requireBlockConfirmations, gasPrice, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, owner, oneEther, halfEther, minPerTx, requireBlockConfirmations, gasPrice, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, owner, oneEther, halfEther, minPerTx, requireBlockConfirmations, gasPrice, homeDailyLimit, homeMaxPerTx, owner, ZERO_ADDRESS, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
true.should.be.equal(await foreignBridge.isInitialized())
rewardableValidators.address.should.be.equal(await foreignBridge.validatorContract());
@ -557,13 +558,15 @@ contract('ForeignBridge', async (accounts) => {
const feeManagerContract = await foreignBridge.feeManagerContract()
feeManagerContract.should.be.equals(feeManager.address)
const bridgeFee = await foreignBridge.getFee()
bridgeFee.should.be.bignumber.equal(fee)
const bridgeHomeFee = await foreignBridge.getHomeFee()
bridgeHomeFee.should.be.bignumber.equal(homeFee)
const bridgeForeignFee = await foreignBridge.getForeignFee()
bridgeForeignFee.should.be.bignumber.equal(foreignFee)
})
it('can update fee contract', async () => {
const feeManager = await FeeManagerNativeToErc.new()
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
// Given
const newFeeManager = await FeeManagerNativeToErc.new()
@ -578,17 +581,21 @@ contract('ForeignBridge', async (accounts) => {
it('can update fee', async () => {
const feeManager = await FeeManagerNativeToErc.new()
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
// Given
const newFee = web3.toBigNumber(web3.toWei(0.1, "ether"))
const newHomeFee = web3.toBigNumber(web3.toWei(0.1, "ether"))
const newForeignFee = web3.toBigNumber(web3.toWei(0.2, "ether"))
// When
await foreignBridge.setFee(newFee, { from: owner }).should.be.fulfilled
await foreignBridge.setHomeFee(newHomeFee, { from: owner }).should.be.fulfilled
await foreignBridge.setForeignFee(newForeignFee, { from: owner }).should.be.fulfilled
// Then
const bridgeFee = await foreignBridge.getFee()
bridgeFee.should.be.bignumber.equal(newFee)
const bridgeHomeFee = await foreignBridge.getHomeFee()
bridgeHomeFee.should.be.bignumber.equal(newHomeFee)
const bridgeForeignFee = await foreignBridge.getForeignFee()
bridgeForeignFee.should.be.bignumber.equal(newForeignFee)
})
it('should be able to get fee manager mode', async () => {
@ -597,7 +604,7 @@ contract('ForeignBridge', async (accounts) => {
const oneDirectionsModeHash = '0xf2aed8f7'
// When
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
// Then
const feeManagerMode = await foreignBridge.getFeeManagerMode()
@ -616,6 +623,7 @@ contract('ForeignBridge', async (accounts) => {
it('should distribute fee to validator', async () => {
const fee = 0.001
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeNotUsedInWei = web3.toBigNumber(web3.toWei(0.5, "ether"))
const value = halfEther
const finalUserValue = value.mul(web3.toBigNumber(1-fee));
const feeAmount = value.mul(web3.toBigNumber(fee))
@ -624,7 +632,7 @@ contract('ForeignBridge', async (accounts) => {
const rewards = [accounts[2]]
const requiredSignatures = 1
await rewardableValidators.initialize(requiredSignatures, validators, rewards, owner).should.be.fulfilled
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, feeInWei).should.be.fulfilled;
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, feeInWei, feeNotUsedInWei).should.be.fulfilled;
await token.transferOwnership(foreignBridge.address);
const recipientAccount = accounts[3];
@ -654,6 +662,7 @@ contract('ForeignBridge', async (accounts) => {
// Given
const fee = 0.001
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeNotUsedInWei = web3.toBigNumber(web3.toWei(0.5, "ether"))
const feePerValidator = web3.toBigNumber(166666666666666)
const feePerValidatorPlusDiff = web3.toBigNumber(166666666666668)
const value = halfEther
@ -663,7 +672,7 @@ contract('ForeignBridge', async (accounts) => {
const rewards = [accounts[4], accounts[5], accounts[6]]
const requiredSignatures = 3
await rewardableValidators.initialize(requiredSignatures, validators, rewards, owner).should.be.fulfilled
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, feeInWei).should.be.fulfilled;
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, feeInWei, feeNotUsedInWei).should.be.fulfilled;
await token.transferOwnership(foreignBridge.address);
const recipientAccount = accounts[7];
@ -715,6 +724,7 @@ contract('ForeignBridge', async (accounts) => {
// Given
const fee = 0.001
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeNotUsedInWei = web3.toBigNumber(web3.toWei(0.5, "ether"))
const value = halfEther
const feeAmount = value.mul(web3.toBigNumber(fee))
const feePerValidator = feeAmount.div(web3.toBigNumber(5))
@ -724,7 +734,7 @@ contract('ForeignBridge', async (accounts) => {
const rewards = [accounts[5], accounts[6], accounts[7], accounts[8], accounts[9]]
const requiredSignatures = 3
await rewardableValidators.initialize(requiredSignatures, validators, rewards, owner).should.be.fulfilled
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, feeInWei).should.be.fulfilled;
await foreignBridge.rewardableInitialize(rewardableValidators.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, homeDailyLimit, homeMaxPerTx, owner, feeManager.address, feeInWei, feeNotUsedInWei).should.be.fulfilled;
await token.transferOwnership(foreignBridge.address);
const recipientAccount = accounts[0];

48
test/native_to_erc/home_bridge_test.js
View File

@ -558,7 +558,7 @@ contract('HomeBridge', async (accounts) => {
})
describe('#rewardableInitialize', async() => {
let fee, homeBridge, rewardableValidators
let homeFee, foreignFee, homeBridge, rewardableValidators
let validators = [accounts[1]]
let rewards = [accounts[2]]
let requiredSignatures = 1
@ -566,7 +566,8 @@ contract('HomeBridge', async (accounts) => {
rewardableValidators = await RewardableValidators.new()
await rewardableValidators.initialize(requiredSignatures, validators, rewards, owner).should.be.fulfilled
homeBridge = await HomeBridge.new()
fee = web3.toBigNumber(web3.toWei(0.001, "ether"))
homeFee = web3.toBigNumber(web3.toWei(0.001, "ether"))
foreignFee = web3.toBigNumber(web3.toWei(0.002, "ether"))
})
it('sets variables', async () => {
const feeManager = await FeeManagerNativeToErc.new()
@ -576,11 +577,11 @@ contract('HomeBridge', async (accounts) => {
'0'.should.be.bignumber.equal(await homeBridge.maxPerTx())
false.should.be.equal(await homeBridge.isInitialized())
await homeBridge.rewardableInitialize(ZERO_ADDRESS, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, 0, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, 0, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.rejectedWith(ERROR_MSG);
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, ZERO_ADDRESS, fee).should.be.rejectedWith(ERROR_MSG);
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await homeBridge.rewardableInitialize(ZERO_ADDRESS, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, 0, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, 0, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, ZERO_ADDRESS, homeFee, foreignFee).should.be.rejectedWith(ERROR_MSG);
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
true.should.be.equal(await homeBridge.isInitialized())
rewardableValidators.address.should.be.equal(await homeBridge.validatorContract());
@ -598,13 +599,15 @@ contract('HomeBridge', async (accounts) => {
const feeManagerContract = await homeBridge.feeManagerContract()
feeManagerContract.should.be.equals(feeManager.address)
const bridgeFee = await homeBridge.getFee()
bridgeFee.should.be.bignumber.equal(fee)
const bridgeHomeFee = await homeBridge.getHomeFee()
bridgeHomeFee.should.be.bignumber.equal(homeFee)
const bridgeForeignFee = await homeBridge.getForeignFee()
bridgeForeignFee.should.be.bignumber.equal(foreignFee)
})
it('can update fee contract', async () => {
const feeManager = await FeeManagerNativeToErc.new()
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
// Given
const newFeeManager = await FeeManagerNativeToErc.new()
@ -619,17 +622,21 @@ contract('HomeBridge', async (accounts) => {
it('can update fee', async () => {
const feeManager = await FeeManagerNativeToErc.new()
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
// Given
const newFee = web3.toBigNumber(web3.toWei(0.1, "ether"))
const newHomeFee = web3.toBigNumber(web3.toWei(0.1, "ether"))
const newForeignFee = web3.toBigNumber(web3.toWei(0.2, "ether"))
// When
await homeBridge.setFee(newFee, { from: owner }).should.be.fulfilled
await homeBridge.setHomeFee(newHomeFee, { from: owner }).should.be.fulfilled
await homeBridge.setForeignFee(newForeignFee, { from: owner }).should.be.fulfilled
// Then
const bridgeFee = await homeBridge.getFee()
bridgeFee.should.be.bignumber.equal(newFee)
const bridgeHomeFee = await homeBridge.getHomeFee()
bridgeHomeFee.should.be.bignumber.equal(newHomeFee)
const bridgeForeignFee = await homeBridge.getForeignFee()
bridgeForeignFee.should.be.bignumber.equal(newForeignFee)
})
it('should be able to get fee manager mode', async () => {
// Given
@ -637,7 +644,7 @@ contract('HomeBridge', async (accounts) => {
const oneDirectionsModeHash = '0xf2aed8f7'
// When
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, fee).should.be.fulfilled;
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, homeFee, foreignFee).should.be.fulfilled;
// Then
const feeManagerMode = await homeBridge.getFeeManagerMode()
@ -661,11 +668,12 @@ contract('HomeBridge', async (accounts) => {
// 0.1% fee
const fee = 0.001
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeNotUsedInWei = web3.toBigNumber(web3.toWei(0.5, "ether"))
const value = halfEther;
const finalUserValue = value.mul(web3.toBigNumber(1-fee));
const feeAmount = value.mul(web3.toBigNumber(fee))
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, feeInWei).should.be.fulfilled;
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, feeNotUsedInWei, feeInWei).should.be.fulfilled;
await homeBridge.sendTransaction({
from: accounts[0],
value: halfEther
@ -710,6 +718,7 @@ contract('HomeBridge', async (accounts) => {
// 0.1% fee
const fee = 0.001
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeNotUsedInWei = web3.toBigNumber(web3.toWei(0.5, "ether"))
const feePerValidator = web3.toBigNumber(166666666666666)
const feePerValidatorPlusDiff = web3.toBigNumber(166666666666668)
const finalUserValue = value.mul(web3.toBigNumber(1-fee));
@ -717,7 +726,7 @@ contract('HomeBridge', async (accounts) => {
const homeBridge = await HomeBridge.new()
const feeManager = await FeeManagerNativeToErc.new()
await rewardableValidators.initialize(requiredSignatures, validators, rewards, owner, {from: owner}).should.be.fulfilled
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, feeInWei).should.be.fulfilled;
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, feeNotUsedInWei, feeInWei).should.be.fulfilled;
await homeBridge.sendTransaction({
from: accounts[0],
value: halfEther
@ -781,6 +790,7 @@ contract('HomeBridge', async (accounts) => {
// 0.1% fee
const fee = 0.001
const feeInWei = web3.toBigNumber(web3.toWei(fee, "ether"))
const feeNotUsedInWei = web3.toBigNumber(web3.toWei(0.5, "ether"))
const feeAmount = value.mul(web3.toBigNumber(fee))
const feePerValidator = feeAmount.div(web3.toBigNumber(5))
@ -788,7 +798,7 @@ contract('HomeBridge', async (accounts) => {
const homeBridge = await HomeBridge.new()
const feeManager = await FeeManagerNativeToErc.new()
await rewardableValidators.initialize(requiredSignatures, validators, rewards, owner, {from: owner}).should.be.fulfilled
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, feeInWei).should.be.fulfilled;
await homeBridge.rewardableInitialize(rewardableValidators.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, foreignDailyLimit, foreignMaxPerTx, owner, feeManager.address, feeNotUsedInWei, feeInWei).should.be.fulfilled;
await homeBridge.sendTransaction({
from: accounts[0],
value: halfEther