diff --git a/contracts/standard/proxy/VersioningProxy.sol b/contracts/standard/proxy/VersioningProxy.sol index f264bc7b..434b9608 100644 --- a/contracts/standard/proxy/VersioningProxy.sol +++ b/contracts/standard/proxy/VersioningProxy.sol @@ -65,7 +65,7 @@ contract VersioningProxy { */ function rollback() external onlyOwner returns(bool _success) { uint256 tagsLen = tags.length; - if (tagsLen <= 2) // We don't have a previous deployment, return false + if (tagsLen < 2) // We don't have a previous deployment, return false return false; // Roll back and return true diff --git a/test/arbitrator-versioning-proxy.js b/test/arbitrator-versioning-proxy.js new file mode 100644 index 00000000..b202f265 --- /dev/null +++ b/test/arbitrator-versioning-proxy.js @@ -0,0 +1,207 @@ +/* eslint-disable no-undef */ // Avoid the linter considering truffle elements as undef. + +const BigNumber = web3.BigNumber +const { + expectThrow +} = require('openzeppelin-solidity/test/helpers/expectThrow') +const { + increaseTime +} = require('openzeppelin-solidity/test/helpers/increaseTime') + +const ARBITRABLE_PERMISSION_LIST = artifacts.require('ArbitrablePermissionList') +const CENTRALIZED_ARBITRATOR = artifacts.require('CentralizedArbitrator') +const MINIME_TOKEN = artifacts.require('MiniMeToken') +const MINIME_TOKEN_FACTORY = artifacts.require('MiniMeTokenFactory') +const ConstantNG = artifacts.require('ConstantNG') +const ARBITRATOR_VERSIONING_PROXY = artifacts.require('ArbitratorVersioningProxy') +const APPEALABLE_ARBITRATOR = artifacts.require('AppealableArbitrator') + +contract('ArbitrableVersioningProxy', function(accounts) { + const PROPOSAL_QUORUM = 60 + const QUORUM_DIVIDE_TIME = 100 + const VOTING_TIME = 1000 + + const CREATOR = accounts[1] + const GOVERNOR = accounts[2] + const ARBITRATOR_EXTRA_DATA = '0x707574546F566F74650000000000000000000000' + const ARBITRATION_FEE = 4 + const STAKE = 10 + const TIME_TO_CHALLENGE = 0 + const META_EVIDENCE = 'evidence' + const BLACKLIST = false + const APPEND_ONLY = true + const RECHALLENGE_POSSIBLE = false + const TIMEOUT = 100 + + const MIN_STAKING_TIME = 1 + const MAX_DRAWINNG_TIME = 1 + + let governance + let arbitrablePermissionList + let centralizedArbitrator + let pinakion + let appealableArbitrator + let tokenFactory + let RNG + let arbitratorVersioningProxy + + const PROPOSAL_STATE = { + NEW: 0, + PUT_TO_SUPPORT: 1, + PUT_TO_VOTE: 2, + DECIDED: 3 + } + + beforeEach('setup contract for each test', async function() { + centralizedArbitrator = await CENTRALIZED_ARBITRATOR.new(ARBITRATION_FEE, { + from: CREATOR + }) + + arbitrablePermissionList = await ARBITRABLE_PERMISSION_LIST.new( + centralizedArbitrator.address, + ARBITRATOR_EXTRA_DATA, + META_EVIDENCE, + BLACKLIST, + APPEND_ONLY, + RECHALLENGE_POSSIBLE, + STAKE, + TIME_TO_CHALLENGE, + { + from: CREATOR + } + ) + + tokenFactory = await MINIME_TOKEN_FACTORY.new({ from: CREATOR }) + + pinakion = await MINIME_TOKEN.new( + tokenFactory.address, + 0x0, + 0, + 'Pinakion', + 18, + 'PNK', + true, + { + from: CREATOR + } + ) + + appealableArbitrator = await APPEALABLE_ARBITRATOR.new( + ARBITRATION_FEE, + GOVERNOR, + ARBITRATOR_EXTRA_DATA, + TIMEOUT + ) + + arbitratorVersioningProxy = await ARBITRATOR_VERSIONING_PROXY.new(appealableArbitrator.address, {from: GOVERNOR}) + + }) + + it('should be possible to retrieve all the tags', async function() { + const ALL_TAGS = await arbitratorVersioningProxy.allTags() + assert.equal(web3.toUtf8(ALL_TAGS[0]), "0.0.1") + }) + + it('should be possible to publish a new version', async function() { + const NEXT_TAG = "NEXT_TAG" + + const NEW_VERSION = await APPEALABLE_ARBITRATOR.new(ARBITRATION_FEE + 1, accounts[9], "NEW_EXTRA_DATA", 0, {from: accounts[8]}) + await arbitratorVersioningProxy.publish(NEXT_TAG, NEW_VERSION.address, {from: GOVERNOR}) + + const IMPLEMENTATION = await arbitratorVersioningProxy.implementation() + + assert.equal(await arbitratorVersioningProxy.addresses(NEXT_TAG), IMPLEMENTATION) + }) + + it('should be possible to rollback to the previous version', async function(){ + const PREV_IMPLEMENTATION = await arbitratorVersioningProxy.implementation() + + + const NEXT_TAG = "NEXT_TAG" + + const NEW_VERSION = await APPEALABLE_ARBITRATOR.new(ARBITRATION_FEE + 1, accounts[9], "NEW_EXTRA_DATA", 0, {from: accounts[8]}) + await arbitratorVersioningProxy.publish(NEXT_TAG, NEW_VERSION.address, {from: GOVERNOR}) + + await arbitratorVersioningProxy.rollback({from: GOVERNOR}) + + const CURRENT_IMPLEMENTATION = await arbitratorVersioningProxy.implementation() + + assert.equal(CURRENT_IMPLEMENTATION, PREV_IMPLEMENTATION) + }) + + it('should be possible to set the stable version to a previously published version', async function(){ + const PREV_IMPLEMENTATION = await arbitratorVersioningProxy.implementation() + const PREV_TAG = (await arbitratorVersioningProxy.allTags())[0] + + const NEXT_TAG = "NEXT_TAG" + + const NEW_VERSION = await APPEALABLE_ARBITRATOR.new(ARBITRATION_FEE + 1, accounts[9], "NEW_EXTRA_DATA", 0, {from: accounts[8]}) + await arbitratorVersioningProxy.publish(NEXT_TAG, NEW_VERSION.address, {from: GOVERNOR}) + + await arbitratorVersioningProxy.setStable(PREV_TAG ,{from: GOVERNOR}) + + const CURRENT_IMPLEMENTATION = await arbitratorVersioningProxy.implementation() + + assert.equal(CURRENT_IMPLEMENTATION, PREV_IMPLEMENTATION) + }) + + it('should be possible to create a dispute', async function(){ + await arbitratorVersioningProxy.createDispute(217, "EXTRA_DATA", {value: 10000000}) + + const IMPLEMENTATION_ADDRESS = await arbitratorVersioningProxy.implementation() + + const ARBITRATOR = APPEALABLE_ARBITRATOR.at(IMPLEMENTATION_ADDRESS) + + assert.equal((await ARBITRATOR.disputes(0))[1].toNumber(), 217) + }) + + it('should be possible to give a ruling to a dispute', async function(){ + const CHOICES = 217 // Arbitrary + + await arbitratorVersioningProxy.createDispute(CHOICES, "EXTRA_DATA", {value: 10000000}) + + const IMPLEMENTATION_ADDRESS = await arbitratorVersioningProxy.implementation() + + const ARBITRATOR = APPEALABLE_ARBITRATOR.at(IMPLEMENTATION_ADDRESS) + + const DISPUTE_ID = 0 // First dispute has the ID 0 + const RULING = CHOICES - 1 // Arbitrary + + + await ARBITRATOR.giveRuling(DISPUTE_ID, RULING) + + const RULING_INDEX = 3 // Ruling field index in DisputeStruct + + assert.equal((await ARBITRATOR.disputes(DISPUTE_ID))[RULING_INDEX].toNumber(), RULING) + }) + + it.only('should be possible to appeal a dispute', async function(){ + const CHOICES = 217 // Arbitrary + const EXTRA_DATA = "EXTRA_DATA" + + await arbitratorVersioningProxy.createDispute(CHOICES, EXTRA_DATA, {value: 1000000}) + + const IMPLEMENTATION_ADDRESS = await arbitratorVersioningProxy.implementation() + + const ARBITRATOR = APPEALABLE_ARBITRATOR.at(IMPLEMENTATION_ADDRESS) + + const DISPUTE_ID = 0 // First dispute has the ID 0 + const RULING = CHOICES - 1 // Arbitrary + + + await ARBITRATOR.giveRuling(DISPUTE_ID, RULING) + + const RULING_INDEX = 3 // Ruling field index in DisputeStruct + + //await increaseTime(10000) + + console.log((await ARBITRATOR.disputes(0))[4].toNumber()) + //await arbitratorVersioningProxy.appeal(DISPUTE_ID, EXTRA_DATA, {gas: 1000000, value: 1}) + + //await ARBITRATOR.appeal(DISPUTE_ID, EXTRA_DATA, {gas: 1000000, value: 100000000}) + + await ARBITRATOR.appealCost(DISPUTE_ID, EXTRA_DATA) // Why does this revert? + }) + + +})