tornadocontrib/tokenbridge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add amb oracle e2e tests

Browse Source
This commit is contained in:
Gerardo Nardelli 2019-06-03 16:56:53 -03:00
parent 0326745684
commit e006443f50
5 changed files with 446 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
oracle-e2e/deploy.js
View File

@ -6,9 +6,12 @@ const envsDir = path.join(__dirname, 'envs')
const deployContractsDir = path.join(__dirname, contractsPath, 'deploy')
const erc20ScriptDir = path.join(__dirname, 'scripts')
// native-erc20
shell.cp(path.join(envsDir, 'contracts-deploy.env'), path.join(deployContractsDir, '.env'))
shell.cd(deployContractsDir)
shell.exec('node deploy.js')
// erc20-erc20
shell.cd(erc20ScriptDir)
shell.exec('node deployERC20.js')
shell.cd(deployContractsDir)
@ -16,9 +19,17 @@ shell.rm('.env')
shell.cp(path.join(envsDir, 'erc-contracts-deploy.env'), path.join(deployContractsDir, '.env'))
shell.exec('node deploy.js')
shell.rm('.env')
// erc20-native
shell.cp(
path.join(envsDir, 'erc-native-contracts-deploy.env'),
path.join(deployContractsDir, '.env')
)
shell.exec('node src/utils/deployBlockReward.js')
shell.exec('node deploy.js')
// amb
shell.rm('.env')
shell.cp(path.join(envsDir, 'amb-contract-deploy.env'), path.join(deployContractsDir, '.env'))
shell.exec('node deploy.js')
shell.exec('node src/utils/deployTestBox.js')

27
oracle-e2e/docker-compose.yml
View File

@ -103,6 +103,33 @@ services:
- FOREIGN_POLLING_INTERVAL=500
- ALLOW_HTTP=yes
command: "true"
bridge-amb:
build:
context: ..
dockerfile: oracle/Dockerfile
environment:
- NODE_ENV=production
- BRIDGE_MODE=ARBITRARY_MESSAGE
- QUEUE_URL=amqp://rabbit
- REDIS_URL=redis://redis
- HOME_RPC_URL=http://parity1:8545
- FOREIGN_RPC_URL=http://parity2:8545
- HOME_BRIDGE_ADDRESS=0x0AEe1FCD12dDFab6265F7f8956e6E012A9Fe4Aa0
- FOREIGN_BRIDGE_ADDRESS=0x0AEe1FCD12dDFab6265F7f8956e6E012A9Fe4Aa0
- VALIDATOR_ADDRESS_PRIVATE_KEY=8e829f695aed89a154550f30262f1529582cc49dc30eff74a6b491359e0230f9
- REDIS_LOCK_TTL=1000
- HOME_GAS_PRICE_ORACLE_URL=https://gasprice.poa.network/
- HOME_GAS_PRICE_SPEED_TYPE=standard
- HOME_GAS_PRICE_FALLBACK=1000000000
- HOME_GAS_PRICE_UPDATE_INTERVAL=600000
- FOREIGN_GAS_PRICE_ORACLE_URL=https://gasprice.poa.network/
- FOREIGN_GAS_PRICE_SPEED_TYPE=standard
- FOREIGN_GAS_PRICE_FALLBACK=10000000000
- FOREIGN_GAS_PRICE_UPDATE_INTERVAL=600000
- HOME_POLLING_INTERVAL=500
- FOREIGN_POLLING_INTERVAL=500
- ALLOW_HTTP=yes
command: "true"
e2e:
build:
context: ..

27
oracle-e2e/envs/amb-contract-deploy.env Normal file
View File

@ -0,0 +1,27 @@
BRIDGE_MODE=ARBITRARY_MESSAGE
DEPLOYMENT_ACCOUNT_PRIVATE_KEY=8e829f695aed89a154550f30262f1529582cc49dc30eff74a6b491359e0230f9
HOME_DEPLOYMENT_GAS_PRICE=10000000000
FOREIGN_DEPLOYMENT_GAS_PRICE=10000000000
GET_RECEIPT_INTERVAL_IN_MILLISECONDS=50
DEPLOYMENT_GAS_LIMIT_EXTRA=0.2
HOME_RPC_URL=http://parity1:8545
HOME_BRIDGE_OWNER=0xaaB52d66283F7A1D5978bcFcB55721ACB467384b
HOME_VALIDATORS_OWNER=0xaaB52d66283F7A1D5978bcFcB55721ACB467384b
HOME_UPGRADEABLE_ADMIN=0xaaB52d66283F7A1D5978bcFcB55721ACB467384b
HOME_MAX_AMOUNT_PER_TX=8000000
HOME_REQUIRED_BLOCK_CONFIRMATIONS=1
HOME_GAS_PRICE=1000000000
HOME_AMB_SUBSIDIZED_MODE=false
FOREIGN_RPC_URL=http://parity2:8545
FOREIGN_BRIDGE_OWNER=0xaaB52d66283F7A1D5978bcFcB55721ACB467384b
FOREIGN_VALIDATORS_OWNER=0xaaB52d66283F7A1D5978bcFcB55721ACB467384b
FOREIGN_UPGRADEABLE_ADMIN=0xaaB52d66283F7A1D5978bcFcB55721ACB467384b
FOREIGN_MAX_AMOUNT_PER_TX=8000000
FOREIGN_REQUIRED_BLOCK_CONFIRMATIONS=1
FOREIGN_GAS_PRICE=10000000000
FOREIGN_AMB_SUBSIDIZED_MODE=false
REQUIRED_NUMBER_OF_VALIDATORS=1
VALIDATORS=0xaaB52d66283F7A1D5978bcFcB55721ACB467384b

3
oracle-e2e/run-tests.sh
View File

@ -13,6 +13,9 @@ docker-compose run -d bridge-erc npm run watcher:affirmation-request
docker-compose run -d bridge-erc-native npm run watcher:signature-request
docker-compose run -d bridge-erc-native npm run watcher:collected-signatures
docker-compose run -d bridge-erc-native npm run watcher:affirmation-request
docker-compose run -d bridge-amb npm run watcher:signature-request
docker-compose run -d bridge-amb npm run watcher:collected-signatures
docker-compose run -d bridge-amb npm run watcher:affirmation-request
docker-compose run -d bridge npm run sender:home
docker-compose run -d bridge npm run sender:foreign
docker-compose run e2e yarn workspace oracle-e2e run start

378
oracle-e2e/test/amb.js Normal file
View File

@ -0,0 +1,378 @@
const path = require('path')
const Web3 = require('web3')
const assert = require('assert')
const promiseRetry = require('promise-retry')
const { user, validator, contractsPath } = require('../constants.json')
const { generateNewBlock } = require('../utils/utils')
const { toBN } = Web3.utils
const abisDir = path.join(__dirname, '..', contractsPath, 'build/contracts')
const homeWeb3 = new Web3(new Web3.providers.HttpProvider('http://parity1:8545'))
const foreignWeb3 = new Web3(new Web3.providers.HttpProvider('http://parity2:8545'))
const homeBridgeAddress = '0x0AEe1FCD12dDFab6265F7f8956e6E012A9Fe4Aa0'
const foreignBridgeAddress = '0x0AEe1FCD12dDFab6265F7f8956e6E012A9Fe4Aa0'
const homeBoxAddress = '0x6C4EaAb8756d53Bf599FFe2347FAFF1123D6C8A1'
const foreignBoxAddress = '0x6C4EaAb8756d53Bf599FFe2347FAFF1123D6C8A1'
homeWeb3.eth.accounts.wallet.add(user.privateKey)
foreignWeb3.eth.accounts.wallet.add(user.privateKey)
homeWeb3.eth.accounts.wallet.add(validator.privateKey)
foreignWeb3.eth.accounts.wallet.add(validator.privateKey)
const homeAbi = require(path.join(abisDir, 'HomeAMB.json')).abi
const foreignAbi = require(path.join(abisDir, 'ForeignAMB.json')).abi
const boxAbi = require(path.join(abisDir, 'Box.json')).abi
const homeAMB = new homeWeb3.eth.Contract(homeAbi, homeBridgeAddress)
const homeBox = new homeWeb3.eth.Contract(boxAbi, homeBoxAddress)
const foreignAMB = new foreignWeb3.eth.Contract(foreignAbi, foreignBridgeAddress)
const foreignBox = new foreignWeb3.eth.Contract(boxAbi, foreignBoxAddress)
const oneEther = foreignWeb3.utils.toWei('1', 'ether')
const subsidizedHash = homeWeb3.utils.toHex('AMB-subsidized-mode')
describe('arbitrary message bridging', () => {
describe('Home to Foreign', () => {
describe('Defrayal Mode', () => {
it('should be able to deposit funds for home sender', async () => {
const initialBalance = await foreignAMB.methods.balanceOf(homeBoxAddress).call()
assert(toBN(initialBalance).isZero(), 'Balance should be zero')
await foreignAMB.methods.depositForContractSender(homeBoxAddress).send({
from: user.address,
gas: '1000000',
value: oneEther
})
const balance = await foreignAMB.methods.balanceOf(homeBoxAddress).call()
assert(toBN(balance).eq(toBN(oneEther)), 'Balance should be one ether')
})
it('should bridge message and take fees', async () => {
const newValue = 9
const initialValue = await foreignBox.methods.value().call()
assert(toBN(initialValue).isZero(), 'Value should be zero')
const initialBalance = await foreignAMB.methods.balanceOf(homeBoxAddress).call()
assert(!toBN(initialBalance).isZero(), 'Balance should not be zero')
const setValueTx = await homeBox.methods
.setValueOnOtherNetworkGasPrice(
newValue,
homeBridgeAddress,
foreignBoxAddress,
'1000000000'
)
.send({
from: user.address,
gas: '1000000'
})
.catch(e => {
console.error(e)
})
// Send a trivial transaction to generate a new block since the watcher
// is configured to wait 1 confirmation block
await generateNewBlock(homeWeb3, user.address)
// The bridge should create a new transaction with a CollectedSignatures
// event so we generate another trivial transaction
await promiseRetry(
async retry => {
const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
if (lastBlockNumber >= setValueTx.blockNumber + 2) {
await generateNewBlock(homeWeb3, user.address)
} else {
retry()
}
},
{
forever: true,
factor: 1,
minTimeout: 500
}
)
// check that value changed and balance decreased
await promiseRetry(async retry => {
const value = await foreignBox.methods.value().call()
const balance = await foreignAMB.methods.balanceOf(homeBoxAddress).call()
if (!toBN(value).eq(toBN(newValue)) || toBN(balance).gte(toBN(oneEther))) {
retry()
}
})
})
it('should be able to withdraw from deposit', async () => {
const initialBalance = await foreignAMB.methods.balanceOf(homeBoxAddress).call()
assert(!toBN(initialBalance).isZero(), 'Balance should not be zero')
const initialUserBalance = toBN(await foreignWeb3.eth.getBalance(user.address))
const tx = await homeBox.methods
.withdrawFromDepositOnOtherNetworkGasPrice(
user.address,
homeBridgeAddress,
foreignBridgeAddress,
'1000000000'
)
.send({
from: user.address,
gas: '1000000'
})
.catch(e => {
console.error(e)
})
// Send a trivial transaction to generate a new block since the watcher
// is configured to wait 1 confirmation block
await generateNewBlock(homeWeb3, user.address)
// The bridge should create a new transaction with a CollectedSignatures
// event so we generate another trivial transaction
await promiseRetry(
async retry => {
const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
if (lastBlockNumber >= tx.blockNumber + 2) {
await generateNewBlock(homeWeb3, user.address)
} else {
retry()
}
},
{
forever: true,
factor: 1,
minTimeout: 500
}
)
// check that value changed and balance decreased
await promiseRetry(async retry => {
const userBalance = toBN(await foreignWeb3.eth.getBalance(user.address))
const boxBalance = toBN(await foreignAMB.methods.balanceOf(homeBoxAddress).call())
if (!boxBalance.isZero() || userBalance.lte(initialUserBalance)) {
retry()
}
})
})
})
describe('Subsidized Mode', () => {
it('should bridge message without taking fees', async () => {
const newValue = 3
await homeAMB.methods.setSubsidizedModeForHomeToForeign().send({
from: validator.address,
gas: '1000000'
})
const homeMode = await homeAMB.methods.homeToForeignMode().call()
await foreignAMB.methods.setSubsidizedModeForHomeToForeign().send({
from: validator.address,
gas: '1000000'
})
const foreignMode = await foreignAMB.methods.homeToForeignMode().call()
assert(homeMode === subsidizedHash, 'home mode incorrect')
assert(foreignMode === subsidizedHash, 'foreign mode incorrect')
const initialValue = await foreignBox.methods.value().call()
assert(
!toBN(initialValue).eq(toBN(newValue)),
'initial value should be different from new value'
)
const setValueTx = await homeBox.methods
.setValueOnOtherNetworkGasPrice(
newValue,
homeBridgeAddress,
foreignBoxAddress,
'1000000000'
)
.send({
from: user.address,
gas: '1000000'
})
.catch(e => {
console.error(e)
})
// Send a trivial transaction to generate a new block since the watcher
// is configured to wait 1 confirmation block
await generateNewBlock(homeWeb3, user.address)
// The bridge should create a new transaction with a CollectedSignatures
// event so we generate another trivial transaction
await promiseRetry(
async retry => {
const lastBlockNumber = await homeWeb3.eth.getBlockNumber()
if (lastBlockNumber >= setValueTx.blockNumber + 2) {
await generateNewBlock(homeWeb3, user.address)
} else {
retry()
}
},
{
forever: true,
factor: 1,
minTimeout: 500
}
)
// check that value changed and balance decreased
await promiseRetry(async retry => {
const value = await foreignBox.methods.value().call()
if (!toBN(value).eq(toBN(newValue))) {
retry()
}
})
})
})
})
describe('Foreign to Home', () => {
describe('Defrayal Mode', () => {
it('should be able to deposit funds for foreign sender', async () => {
const initialBalance = await homeAMB.methods.balanceOf(foreignBoxAddress).call()
assert(toBN(initialBalance).isZero(), 'Balance should be zero')
await homeAMB.methods.depositForContractSender(homeBoxAddress).send({
from: user.address,
gas: '1000000',
value: oneEther
})
const balance = await homeAMB.methods.balanceOf(foreignBoxAddress).call()
assert(toBN(balance).eq(toBN(oneEther)), 'Balance should be one ether')
})
it('should bridge message and take fees', async () => {
const newValue = 6
const initialValue = await homeBox.methods.value().call()
assert(toBN(initialValue).isZero(), 'Value should be zero')
const initialBalance = await homeAMB.methods.balanceOf(foreignBoxAddress).call()
assert(!toBN(initialBalance).isZero(), 'Balance should not be zero')
await foreignBox.methods
.setValueOnOtherNetworkGasPrice(
newValue,
foreignBridgeAddress,
homeBoxAddress,
'1000000000'
)
.send({
from: user.address,
gas: '1000000'
})
.catch(e => {
console.error(e)
})
// Send a trivial transaction to generate a new block since the watcher
// is configured to wait 1 confirmation block
await generateNewBlock(foreignWeb3, user.address)
// check that value changed and balance decreased
await promiseRetry(async retry => {
const value = await homeBox.methods.value().call()
const balance = await homeAMB.methods.balanceOf(foreignBoxAddress).call()
if (!toBN(value).eq(toBN(newValue)) || toBN(balance).gte(toBN(oneEther))) {
retry()
}
})
})
it('should be able to withdraw from deposit', async () => {
const initialBalance = await homeAMB.methods.balanceOf(foreignBoxAddress).call()
assert(!toBN(initialBalance).isZero(), 'Balance should not be zero')
const initialUserBalance = toBN(await homeWeb3.eth.getBalance(user.address))
await foreignBox.methods
.withdrawFromDepositOnOtherNetworkGasPrice(
user.address,
foreignBridgeAddress,
homeBridgeAddress,
'1000000000'
)
.send({
from: user.address,
gas: '1000000'
})
.catch(e => {
console.error(e)
})
// Send a trivial transaction to generate a new block since the watcher
// is configured to wait 1 confirmation block
await generateNewBlock(foreignWeb3, user.address)
// check that value changed and balance decreased
await promiseRetry(async retry => {
const userBalance = toBN(await homeWeb3.eth.getBalance(user.address))
const boxBalance = toBN(await homeAMB.methods.balanceOf(foreignBoxAddress).call())
if (!boxBalance.isZero() || userBalance.lte(initialUserBalance)) {
retry()
}
})
})
})
describe('Subsidized Mode', () => {
it('should bridge message without taking fees', async () => {
const newValue = 7
await homeAMB.methods.setSubsidizedModeForForeignToHome().send({
from: validator.address,
gas: '1000000'
})
const homeMode = await homeAMB.methods.foreignToHomeMode().call()
await foreignAMB.methods.setSubsidizedModeForForeignToHome().send({
from: validator.address,
gas: '1000000'
})
const foreignMode = await foreignAMB.methods.foreignToHomeMode().call()
assert(homeMode === subsidizedHash, 'home mode incorrect')
assert(foreignMode === subsidizedHash, 'foreign mode incorrect')
const initialValue = await homeBox.methods.value().call()
assert(
!toBN(initialValue).eq(toBN(newValue)),
'initial value should be different from new value'
)
await foreignBox.methods
.setValueOnOtherNetworkGasPrice(
newValue,
homeBridgeAddress,
foreignBoxAddress,
'1000000000'
)
.send({
from: user.address,
gas: '1000000'
})
.catch(e => {
console.error(e)
})
// Send a trivial transaction to generate a new block since the watcher
// is configured to wait 1 confirmation block
await generateNewBlock(foreignWeb3, user.address)
// check that value changed and balance decreased
await promiseRetry(async retry => {
const value = await homeBox.methods.value().call()
if (!toBN(value).eq(toBN(newValue))) {
retry()
}
})
})
})
})
})