579 lines
24 KiB
JavaScript
579 lines
24 KiB
JavaScript
const Web3 = require('web3')
|
|
const assert = require('assert')
|
|
const { ASYNC_CALL_ERRORS } = require('../../oracle/src/utils/constants')
|
|
const { user, homeRPC, foreignRPC, amb, validator } = require('../../e2e-commons/constants.json')
|
|
const { uniformRetry } = require('../../e2e-commons/utils')
|
|
const { BOX_ABI, HOME_AMB_ABI, FOREIGN_AMB_ABI, ambInformationSignatures } = require('../../commons')
|
|
const { delay, setRequiredSignatures } = require('./utils')
|
|
|
|
const { toBN } = Web3.utils
|
|
|
|
const homeWeb3 = new Web3(new Web3.providers.HttpProvider(homeRPC.URL))
|
|
const foreignWeb3 = new Web3(new Web3.providers.HttpProvider(foreignRPC.URL))
|
|
|
|
homeWeb3.eth.accounts.wallet.add(user.privateKey)
|
|
homeWeb3.eth.accounts.wallet.add(validator.privateKey)
|
|
foreignWeb3.eth.accounts.wallet.add(user.privateKey)
|
|
foreignWeb3.eth.accounts.wallet.add(validator.privateKey)
|
|
|
|
const opts = {
|
|
from: user.address,
|
|
gas: 400000,
|
|
gasPrice: '1'
|
|
}
|
|
const homeBox = new homeWeb3.eth.Contract(BOX_ABI, amb.homeBox, opts)
|
|
const blockHomeBox = new homeWeb3.eth.Contract(BOX_ABI, amb.blockedHomeBox, opts)
|
|
const foreignBox = new foreignWeb3.eth.Contract(BOX_ABI, amb.foreignBox, opts)
|
|
const homeBridge = new homeWeb3.eth.Contract(HOME_AMB_ABI, amb.home, opts)
|
|
const foreignBridge = new foreignWeb3.eth.Contract(FOREIGN_AMB_ABI, amb.foreign, opts)
|
|
|
|
function validateBlock(web3, serialized, block) {
|
|
assert.strictEqual(serialized.length, 2 + 64 * 12)
|
|
const values = web3.eth.abi.decodeParameter(
|
|
'(uint256,bytes32,address,uint256,uint256,bytes32,bytes32,bytes32,bytes32,uint256,uint256,uint256)',
|
|
serialized
|
|
)
|
|
assert.strictEqual(values[0], block.number.toString(), 'wrong block number returned')
|
|
assert.strictEqual(values[1], block.hash, 'wrong block hash returned')
|
|
assert.strictEqual(values[2], block.miner, 'wrong block miner returned')
|
|
assert.strictEqual(values[3], block.gasUsed.toString(), 'wrong block gasUsed returned')
|
|
assert.strictEqual(values[4], block.gasLimit.toString(), 'wrong block gasLimit returned')
|
|
assert.strictEqual(values[5], block.parentHash, 'wrong block parentHash returned')
|
|
assert.strictEqual(values[6], block.receiptsRoot, 'wrong block receiptsRoot returned')
|
|
assert.strictEqual(values[7], block.stateRoot, 'wrong block stateRoot returned')
|
|
assert.strictEqual(values[8], block.transactionsRoot, 'wrong block transactionsRoot returned')
|
|
assert.strictEqual(values[9], block.timestamp.toString(), 'wrong block timestamp returned')
|
|
assert.strictEqual(values[10], block.difficulty, 'wrong block difficulty returned')
|
|
assert.strictEqual(values[11], block.totalDifficulty, 'wrong block totalDifficulty returned')
|
|
}
|
|
|
|
function validateTransaction(web3, serialized, tx) {
|
|
assert.strictEqual(serialized.length, 64 * 13 + tx.input.length + 56)
|
|
const values = web3.eth.abi.decodeParameter(
|
|
'(bytes32,uint256,bytes32,uint256,address,address,uint256,uint256,uint256,uint256,bytes)',
|
|
serialized
|
|
)
|
|
assert.strictEqual(values[0], tx.hash, 'wrong txHash returned')
|
|
assert.strictEqual(values[1], tx.blockNumber.toString(), 'wrong tx blockNumber returned')
|
|
assert.strictEqual(values[2], tx.blockHash.toString(), 'wrong tx blockHash returned')
|
|
assert.strictEqual(values[3], tx.transactionIndex.toString(), 'wrong tx transactionIndex returned')
|
|
assert.strictEqual(values[4], tx.from, 'wrong tx from returned')
|
|
assert.strictEqual(values[5], tx.to, 'wrong tx to returned')
|
|
assert.strictEqual(values[6], tx.value, 'wrong tx value returned')
|
|
assert.strictEqual(values[7], tx.nonce.toString(), 'wrong tx nonce returned')
|
|
assert.strictEqual(values[8], tx.gas.toString(), 'wrong tx gas returned')
|
|
assert.strictEqual(values[9], tx.gasPrice, 'wrong tx gasPrice returned')
|
|
assert.strictEqual(values[10], tx.input, 'wrong tx data returned')
|
|
}
|
|
|
|
describe('arbitrary message bridging', () => {
|
|
let requiredSignatures = 1
|
|
before(async () => {
|
|
for (const method of ambInformationSignatures) {
|
|
const selector = homeWeb3.utils.soliditySha3(method)
|
|
await homeBridge.methods.enableAsyncRequestSelector(selector, true).send({ from: validator.address })
|
|
}
|
|
|
|
// Only 1 validator is used in ultimate tests
|
|
if (process.env.ULTIMATE === 'true') {
|
|
return
|
|
}
|
|
console.log('Calling setRequiredSignatures(2)')
|
|
|
|
requiredSignatures = 2
|
|
// Set 2 required signatures for home bridge
|
|
await setRequiredSignatures({
|
|
bridgeContract: homeBridge,
|
|
web3: homeWeb3,
|
|
requiredSignatures: 2,
|
|
options: {
|
|
from: validator.address,
|
|
gas: '4000000'
|
|
}
|
|
})
|
|
|
|
// Set 2 required signatures for foreign bridge
|
|
await setRequiredSignatures({
|
|
bridgeContract: foreignBridge,
|
|
web3: foreignWeb3,
|
|
requiredSignatures: 2,
|
|
options: {
|
|
from: validator.address,
|
|
gas: '4000000'
|
|
}
|
|
})
|
|
})
|
|
if (process.env.ULTIMATE !== 'true') {
|
|
describe('Confirm Relay', () => {
|
|
it('should process lost affirmation-request via confirm relay', async () => {
|
|
const value = await homeBox.methods.value().call()
|
|
assert(value === '789', 'incorrect value')
|
|
})
|
|
|
|
it('should process lost signature-request & collected-signatures via confirm relay', async () => {
|
|
const value = await foreignBox.methods.value().call()
|
|
assert(value === '123', 'incorrect value')
|
|
})
|
|
})
|
|
}
|
|
describe('Home to Foreign', () => {
|
|
describe('Subsidized Mode', () => {
|
|
it('should bridge message', async () => {
|
|
const newValue = 3
|
|
|
|
const initialValue = await foreignBox.methods.value().call()
|
|
assert(!toBN(initialValue).eq(toBN(newValue)), 'initial value should be different from new value')
|
|
|
|
const res = await homeBox.methods
|
|
.setValueOnOtherNetwork(newValue, amb.home, amb.foreignBox)
|
|
.send()
|
|
.catch(e => {
|
|
console.error(e)
|
|
})
|
|
console.log(res.transactionHash)
|
|
|
|
// check that value changed and balance decreased
|
|
await uniformRetry(async retry => {
|
|
const value = await foreignBox.methods.value().call()
|
|
if (!toBN(value).eq(toBN(newValue))) {
|
|
retry()
|
|
}
|
|
})
|
|
})
|
|
|
|
// allowance/block lists files are not mounted to the host during the ultimate test
|
|
if (process.env.ULTIMATE !== 'true') {
|
|
it('should confirm but not relay message from blocked contract', async () => {
|
|
const newValue = 4
|
|
|
|
const initialValue = await foreignBox.methods.value().call()
|
|
assert(!toBN(initialValue).eq(toBN(newValue)), 'initial value should be different from new value')
|
|
|
|
const signatures = await homeBridge.getPastEvents('SignedForUserRequest', {
|
|
fromBlock: 0,
|
|
toBlock: 'latest'
|
|
})
|
|
|
|
await blockHomeBox.methods
|
|
.setValueOnOtherNetwork(newValue, amb.home, amb.foreignBox)
|
|
.send()
|
|
.catch(e => {
|
|
console.error(e)
|
|
})
|
|
|
|
await delay(5000)
|
|
|
|
const newSignatures = await homeBridge.getPastEvents('SignedForUserRequest', {
|
|
fromBlock: 0,
|
|
toBlock: 'latest'
|
|
})
|
|
|
|
assert(
|
|
newSignatures.length === signatures.length + requiredSignatures,
|
|
`Incorrect amount of signatures submitted, got ${newSignatures.length}, expected ${signatures.length +
|
|
requiredSignatures}`
|
|
)
|
|
|
|
const value = await foreignBox.methods.value().call()
|
|
assert(!toBN(value).eq(toBN(newValue)), 'Message should not be relayed by oracle automatically')
|
|
})
|
|
}
|
|
|
|
it('should confirm but not relay message from manual lane', async () => {
|
|
const newValue = 5
|
|
|
|
const initialValue = await foreignBox.methods.value().call()
|
|
assert(!toBN(initialValue).eq(toBN(newValue)), 'initial value should be different from new value')
|
|
|
|
const signatures = await homeBridge.getPastEvents('SignedForUserRequest', {
|
|
fromBlock: 0,
|
|
toBlock: 'latest'
|
|
})
|
|
|
|
await homeBox.methods
|
|
.setValueOnOtherNetworkUsingManualLane(newValue, amb.home, amb.foreignBox)
|
|
.send()
|
|
.catch(e => {
|
|
console.error(e)
|
|
})
|
|
|
|
await delay(10000)
|
|
|
|
const newSignatures = await homeBridge.getPastEvents('SignedForUserRequest', {
|
|
fromBlock: 0,
|
|
toBlock: 'latest'
|
|
})
|
|
|
|
assert(
|
|
newSignatures.length === signatures.length + requiredSignatures,
|
|
`Incorrect amount of signatures submitted, got ${newSignatures.length}, expected ${signatures.length +
|
|
requiredSignatures}`
|
|
)
|
|
|
|
const value = await foreignBox.methods.value().call()
|
|
assert(!toBN(value).eq(toBN(newValue)), 'Message should not be relayed by oracle automatically')
|
|
})
|
|
})
|
|
})
|
|
describe('Foreign to Home', () => {
|
|
describe('Subsidized Mode', () => {
|
|
it('should bridge message', async () => {
|
|
const newValue = 7
|
|
|
|
const initialValue = await homeBox.methods.value().call()
|
|
assert(!toBN(initialValue).eq(toBN(newValue)), 'initial value should be different from new value')
|
|
|
|
const res = await foreignBox.methods
|
|
.setValueOnOtherNetwork(newValue, amb.foreign, amb.homeBox)
|
|
.send()
|
|
.catch(e => {
|
|
console.error(e)
|
|
})
|
|
console.log(res.transactionHash)
|
|
|
|
// check that value changed and balance decreased
|
|
await uniformRetry(async retry => {
|
|
const value = await homeBox.methods.value().call()
|
|
if (!toBN(value).eq(toBN(newValue))) {
|
|
retry()
|
|
}
|
|
})
|
|
})
|
|
})
|
|
})
|
|
describe('Home to Foreign Async Call', () => {
|
|
async function makeAsyncCall(selector, data) {
|
|
const prevMessageId = await homeBox.methods.messageId().call()
|
|
|
|
await homeBox.methods
|
|
.makeAsyncCall(amb.home, selector, data)
|
|
.send()
|
|
.catch(e => {
|
|
console.error(e)
|
|
})
|
|
|
|
// check that value changed and balance decreased
|
|
await uniformRetry(async retry => {
|
|
const messageId = await homeBox.methods.messageId().call()
|
|
if (messageId === prevMessageId) {
|
|
retry()
|
|
}
|
|
})
|
|
}
|
|
|
|
it('should make async eth_call', async () => {
|
|
const foreignValue = await foreignBox.methods.value().call()
|
|
const selector = homeWeb3.utils.soliditySha3('eth_call(address,bytes)')
|
|
const data = homeWeb3.eth.abi.encodeParameters(
|
|
['address', 'bytes'],
|
|
[amb.foreignBox, foreignBox.methods.value().encodeABI()]
|
|
)
|
|
|
|
await makeAsyncCall(selector, data)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
assert.strictEqual(
|
|
await homeBox.methods.data().call(),
|
|
homeWeb3.eth.abi.encodeParameters(['bytes'], [homeWeb3.eth.abi.encodeParameter('uint256', foreignValue)]),
|
|
'returned data is incorrect'
|
|
)
|
|
})
|
|
|
|
it('should make async eth_call with 4 arguments', async () => {
|
|
const foreignValue = await foreignBox.methods.value().call()
|
|
const selector = homeWeb3.utils.soliditySha3('eth_call(address,address,uint256,bytes)')
|
|
const data1 = homeWeb3.eth.abi.encodeParameters(
|
|
['address', 'address', 'uint256', 'bytes'],
|
|
[amb.foreignBox, user.address, '100000', foreignBox.methods.value().encodeABI()]
|
|
)
|
|
|
|
await makeAsyncCall(selector, data1)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
assert.strictEqual(
|
|
await homeBox.methods.data().call(),
|
|
homeWeb3.eth.abi.encodeParameters(['bytes'], [homeWeb3.eth.abi.encodeParameter('uint256', foreignValue)]),
|
|
'returned data is incorrect'
|
|
)
|
|
|
|
const data2 = homeWeb3.eth.abi.encodeParameters(
|
|
['address', 'address', 'uint256', 'bytes'],
|
|
[amb.foreignBox, user.address, '1000', foreignBox.methods.value().encodeABI()]
|
|
)
|
|
|
|
await makeAsyncCall(selector, data2)
|
|
|
|
assert(!(await homeBox.methods.status().call()), 'status is true')
|
|
assert.strictEqual(await homeBox.methods.data().call(), ASYNC_CALL_ERRORS.REVERT, 'returned data is incorrect')
|
|
|
|
const data3 = homeWeb3.eth.abi.encodeParameters(
|
|
['address', 'address', 'uint256', 'bytes'],
|
|
[amb.foreignBox, user.address, '21300', foreignBox.methods.value().encodeABI()]
|
|
)
|
|
|
|
await makeAsyncCall(selector, data3)
|
|
|
|
assert(!(await homeBox.methods.status().call()), 'status is true')
|
|
assert.strictEqual(await homeBox.methods.data().call(), ASYNC_CALL_ERRORS.REVERT, 'returned data is incorrect')
|
|
})
|
|
|
|
it('should make async eth_call for specific block', async () => {
|
|
const foreignValue = await foreignBox.methods.value().call()
|
|
const blockNumber = await foreignWeb3.eth.getBlockNumber()
|
|
const selector = homeWeb3.utils.soliditySha3('eth_call(address,bytes,uint256)')
|
|
const data1 = homeWeb3.eth.abi.encodeParameters(
|
|
['address', 'bytes', 'uint256'],
|
|
[amb.foreignBox, foreignBox.methods.value().encodeABI(), 25]
|
|
)
|
|
const data2 = homeWeb3.eth.abi.encodeParameters(
|
|
['address', 'bytes', 'uint256'],
|
|
[amb.foreignBox, foreignBox.methods.value().encodeABI(), blockNumber - 2]
|
|
)
|
|
const data3 = homeWeb3.eth.abi.encodeParameters(
|
|
['address', 'bytes', 'uint256'],
|
|
[amb.foreignBox, foreignBox.methods.value().encodeABI(), blockNumber + 20]
|
|
)
|
|
|
|
await makeAsyncCall(selector, data1)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
assert.strictEqual(
|
|
await homeBox.methods.data().call(),
|
|
homeWeb3.eth.abi.encodeParameters(['bytes'], [homeWeb3.eth.abi.encodeParameter('uint256', 0)]),
|
|
'returned data is incorrect'
|
|
)
|
|
|
|
await makeAsyncCall(selector, data2)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
assert.strictEqual(
|
|
await homeBox.methods.data().call(),
|
|
homeWeb3.eth.abi.encodeParameters(['bytes'], [homeWeb3.eth.abi.encodeParameter('uint256', foreignValue)]),
|
|
'returned data is incorrect'
|
|
)
|
|
|
|
await makeAsyncCall(selector, data3)
|
|
|
|
assert(!(await homeBox.methods.status().call()), 'status is true')
|
|
assert.strictEqual(
|
|
await homeBox.methods.data().call(),
|
|
ASYNC_CALL_ERRORS.BLOCK_IS_IN_THE_FUTURE,
|
|
'returned data is incorrect'
|
|
)
|
|
})
|
|
|
|
it('should make async eth_blockNumber', async () => {
|
|
const selector = homeWeb3.utils.soliditySha3('eth_blockNumber()')
|
|
|
|
await makeAsyncCall(selector, '0x')
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
assert.strictEqual((await homeBox.methods.data().call()).length, 66, 'invalid block number')
|
|
})
|
|
|
|
it('should make async eth_getBlockByNumber', async () => {
|
|
const blockNumber = ((await foreignWeb3.eth.getBlockNumber()) - 5).toString()
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getBlockByNumber(uint256)')
|
|
|
|
await makeAsyncCall(selector, homeWeb3.eth.abi.encodeParameter('uint256', blockNumber))
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
const data = await homeBox.methods.data().call()
|
|
const block = await foreignWeb3.eth.getBlock(blockNumber)
|
|
validateBlock(homeWeb3, data, block)
|
|
})
|
|
|
|
it('should make async eth_getBlockByNumber and return latest block', async () => {
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getBlockByNumber()')
|
|
|
|
await makeAsyncCall(selector, '0x')
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
const data = await homeBox.methods.data().call()
|
|
assert.strictEqual(data.length, 2 + 64 * 12)
|
|
})
|
|
|
|
it('should make async eth_getBlockByHash', async () => {
|
|
const blockNumber = ((await foreignWeb3.eth.getBlockNumber()) - 5).toString()
|
|
const block = await foreignWeb3.eth.getBlock(blockNumber)
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getBlockByHash(bytes32)')
|
|
|
|
await makeAsyncCall(selector, block.hash)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
const data = await homeBox.methods.data().call()
|
|
validateBlock(homeWeb3, data, block)
|
|
})
|
|
|
|
it('should make async eth_getBalance', async () => {
|
|
const balance = await foreignWeb3.eth.getBalance(user.address)
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getBalance(address)')
|
|
|
|
await makeAsyncCall(selector, homeWeb3.eth.abi.encodeParameter('address', user.address))
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
const data = await homeBox.methods.data().call()
|
|
assert.strictEqual(data.length, 2 + 64)
|
|
|
|
assert.strictEqual(homeWeb3.eth.abi.decodeParameter('uint256', data), balance, 'wrong user balance returned')
|
|
})
|
|
|
|
it('should make async eth_getBalance for specific block', async () => {
|
|
const balance = await foreignWeb3.eth.getBalance(user.address)
|
|
const { blockNumber } = await foreignWeb3.eth.sendTransaction({
|
|
to: user.address,
|
|
value: 1,
|
|
from: user.address,
|
|
gas: 21000
|
|
})
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getBalance(address,uint256)')
|
|
|
|
const data1 = homeWeb3.eth.abi.encodeParameters(['address', 'uint256'], [user.address, blockNumber - 1])
|
|
const data2 = homeWeb3.eth.abi.encodeParameters(['address', 'uint256'], [user.address, blockNumber])
|
|
await makeAsyncCall(selector, data1)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
let data = await homeBox.methods.data().call()
|
|
assert.strictEqual(data.length, 2 + 64)
|
|
|
|
assert.strictEqual(homeWeb3.eth.abi.decodeParameter('uint256', data), balance, 'wrong user balance returned')
|
|
|
|
await makeAsyncCall(selector, data2)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
data = await homeBox.methods.data().call()
|
|
assert.strictEqual(data.length, 2 + 64)
|
|
|
|
assert.notStrictEqual(homeWeb3.eth.abi.decodeParameter('uint256', data), balance, 'wrong user balance returned')
|
|
})
|
|
|
|
it('should make async eth_getTransactionCount', async () => {
|
|
const nonce = (await foreignWeb3.eth.getTransactionCount(user.address)).toString()
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getTransactionCount(address)')
|
|
|
|
await makeAsyncCall(selector, homeWeb3.eth.abi.encodeParameter('address', user.address))
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
const data = await homeBox.methods.data().call()
|
|
assert.strictEqual(data.length, 2 + 64)
|
|
|
|
assert.strictEqual(homeWeb3.eth.abi.decodeParameter('uint256', data), nonce, 'wrong user nonce returned')
|
|
})
|
|
|
|
it('should make async eth_getTransactionCount for specific block', async () => {
|
|
let nonce = (await foreignWeb3.eth.getTransactionCount(user.address)).toString()
|
|
const { blockNumber } = await foreignWeb3.eth.sendTransaction({
|
|
to: user.address,
|
|
value: 1,
|
|
from: user.address,
|
|
gas: 21000
|
|
})
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getTransactionCount(address,uint256)')
|
|
|
|
const data1 = homeWeb3.eth.abi.encodeParameters(['address', 'uint256'], [user.address, blockNumber - 1])
|
|
const data2 = homeWeb3.eth.abi.encodeParameters(['address', 'uint256'], [user.address, blockNumber])
|
|
|
|
await makeAsyncCall(selector, data1)
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
let data = await homeBox.methods.data().call()
|
|
assert.strictEqual(data.length, 2 + 64)
|
|
|
|
assert.strictEqual(homeWeb3.eth.abi.decodeParameter('uint256', data), nonce, 'wrong user nonce returned')
|
|
|
|
await makeAsyncCall(selector, data2)
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
data = await homeBox.methods.data().call()
|
|
assert.strictEqual(data.length, 2 + 64)
|
|
|
|
nonce = (parseInt(nonce, 10) + 1).toString()
|
|
assert.strictEqual(homeWeb3.eth.abi.decodeParameter('uint256', data), nonce, 'wrong user nonce returned')
|
|
})
|
|
|
|
it('should make async eth_getTransactionByHash', async () => {
|
|
const txHash = '0x7262f7dbe6c30599edded2137fbbe93c271b37f5c54dd27f713f0cf510e3b4dd'
|
|
const tx = await foreignWeb3.eth.getTransaction(txHash)
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getTransactionByHash(bytes32)')
|
|
|
|
await makeAsyncCall(selector, txHash)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
const data = await homeBox.methods.data().call()
|
|
validateTransaction(homeWeb3, data, tx)
|
|
})
|
|
|
|
it('should make async eth_getTransactionReceipt', async () => {
|
|
const txHash = '0x7262f7dbe6c30599edded2137fbbe93c271b37f5c54dd27f713f0cf510e3b4dd'
|
|
const receipt = await foreignWeb3.eth.getTransactionReceipt(txHash)
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getTransactionReceipt(bytes32)')
|
|
|
|
await makeAsyncCall(selector, txHash)
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
const data = await homeBox.methods.data().call()
|
|
const values = homeWeb3.eth.abi.decodeParameter(
|
|
'(bytes32,uint256,bytes32,uint256,address,address,uint256,bool,(address,bytes32[],bytes)[])',
|
|
data
|
|
)
|
|
|
|
assert.strictEqual(values[0], txHash, 'wrong txHash returned')
|
|
assert.strictEqual(values[1], receipt.blockNumber.toString(), 'wrong tx blockNumber returned')
|
|
assert.strictEqual(values[2], receipt.blockHash, 'wrong tx blockHash returned')
|
|
assert.strictEqual(values[3], receipt.transactionIndex.toString(), 'wrong tx transactionIndex returned')
|
|
assert.strictEqual(values[4].toLowerCase(), receipt.from, 'wrong tx from returned')
|
|
assert.strictEqual(values[5].toLowerCase(), receipt.to, 'wrong tx to returned')
|
|
assert.strictEqual(values[6], receipt.gasUsed.toString(), 'wrong gasUsed to returned')
|
|
assert.strictEqual(values[7], receipt.status, 'wrong tx status returned')
|
|
assert.strictEqual(values[8].length, 1, 'wrong logs length returned')
|
|
assert.strictEqual(values[8][0][0], receipt.logs[0].address, 'wrong log address returned')
|
|
assert.strictEqual(values[8][0][1].length, 2, 'wrong log topics length returned')
|
|
assert.strictEqual(values[8][0][1][0], receipt.logs[0].topics[0], 'wrong event signature returned')
|
|
assert.strictEqual(values[8][0][1][1], receipt.logs[0].topics[1], 'wrong message id returned')
|
|
assert.strictEqual(values[8][0][2], receipt.logs[0].data, 'wrong log data returned')
|
|
})
|
|
|
|
it('should make async eth_getStorageAt', async () => {
|
|
// slot for uintStorage[MAX_GAS_PER_TX]
|
|
const slot = '0x3d7fe2ee9790702383ef0118b516833ef2542132d3ca4ac6c77f62f1230fa610'
|
|
const value = await foreignWeb3.eth.getStorageAt(amb.foreign, slot)
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getStorageAt(address,bytes32)')
|
|
|
|
await makeAsyncCall(selector, homeWeb3.eth.abi.encodeParameters(['address', 'bytes32'], [amb.foreign, slot]))
|
|
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
const data = await homeBox.methods.data().call()
|
|
|
|
assert.strictEqual(data, value, 'wrong storage value returned')
|
|
})
|
|
|
|
it('should make async eth_getStorageAt for specific block', async () => {
|
|
// slot for uintStorage[MAX_GAS_PER_TX]
|
|
const slot = '0x3d7fe2ee9790702383ef0118b516833ef2542132d3ca4ac6c77f62f1230fa610'
|
|
const value = await foreignWeb3.eth.getStorageAt(amb.foreign, slot)
|
|
const blockNumber = await foreignWeb3.eth.getBlockNumber()
|
|
const selector = homeWeb3.utils.soliditySha3('eth_getStorageAt(address,bytes32,uint256)')
|
|
|
|
const data1 = homeWeb3.eth.abi.encodeParameters(
|
|
['address', 'bytes32', 'uint256'],
|
|
[amb.foreign, slot, blockNumber]
|
|
)
|
|
const data2 = homeWeb3.eth.abi.encodeParameters(['address', 'bytes32', 'uint256'], [amb.foreign, slot, 1])
|
|
|
|
await makeAsyncCall(selector, data1)
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
let data = await homeBox.methods.data().call()
|
|
|
|
assert.strictEqual(data, value, 'wrong storage value returned')
|
|
|
|
await makeAsyncCall(selector, data2)
|
|
assert(await homeBox.methods.status().call(), 'status is false')
|
|
data = await homeBox.methods.data().call()
|
|
|
|
assert.strictEqual(
|
|
data,
|
|
'0x0000000000000000000000000000000000000000000000000000000000000000',
|
|
'wrong storage value returned'
|
|
)
|
|
})
|
|
})
|
|
})
|