Contributor app tests #143
@ -28,5 +28,6 @@ module.exports = {
|
||||
named: 'always',
|
||||
asyncArrow: 'always',
|
||||
}],
|
||||
'indent': ['error', 2]
|
||||
}
|
||||
}
|
||||
|
||||
@ -10,161 +10,161 @@ const { assertRevert } = require('@aragon/test-helpers/assertThrow');
|
||||
|
|
||||
const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
|
||||
|
||||
contract('Contributor app', (accounts) => {
|
||||
let kernelBase, aclBase, daoFactory, r, dao, acl, contributor;
|
||||
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
const root = accounts[0];
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
const member1 = accounts[1];
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let kernelBase, aclBase, daoFactory, r, dao, acl, contributor;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
const root = accounts[0];
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
const member1 = accounts[1];
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
before(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
kernelBase = await getContract('Kernel').new(true); // petrify immediately
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
aclBase = await getContract('ACL').new();
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
r = await daoFactory.newDAO(root);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
acl = getContract('ACL').at(await dao.acl());
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//create dao mamnager permission for coin owner
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await acl.createPermission(
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
root,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
dao.address,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await dao.APP_MANAGER_ROLE(),
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
root,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
{ from: root }
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//get new app instance from DAO
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
const receipt = await dao.newAppInstance(
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'0x1234',
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
(await Contributor.new()).address,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
0x0,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
false,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
{ from: root }
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
contributor = Contributor.at(
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//apps id
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let appsId = [];
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
appsId[0] = namehash("kredits-contribution");
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
appsId[1] = namehash("kredits-contributor");
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
appsId[2] = namehash("kredits-proposal");
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
appsId[3] = namehash("kredits-token");
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//init contributor (app)
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.initialize(root, appsId);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//create manage contributors role
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await acl.createPermission(
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
root,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
contributor.address,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.MANAGE_CONTRIBUTORS_ROLE(),
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
root,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
{ from: root }
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
describe("Owner default space permissions", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it('check owner is token issuer', async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let manageContributorPermission = await acl.hasPermission(root, contributor.address, await contributor.MANAGE_CONTRIBUTORS_ROLE());
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(manageContributorPermission, true);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
describe("Add contributor", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let account = root;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashDigest = '0x0';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashFunction = 0;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashSize = 0;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when add contributor from an address that does not have permission", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'sender does not have permission';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it('add contributor', async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let contributorCount = await contributor.coreContributorsCount();
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.addContributor(account, hashDigest, hashFunction, hashSize);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(await contributor.addressExists(account), true);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let contributorCountAfter = await contributor.coreContributorsCount();
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(await contributorCountAfter.toNumber(), parseInt(contributorCount)+1);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when add contributor with an address that already exist", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'address already exist';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
describe("Update contributor", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let id;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let oldAccount;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let newAccount;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashDigest;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashFunction;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashSize;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
before(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
kernelBase = await getContract('Kernel').new(true); // petrify immediately
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
aclBase = await getContract('ACL').new();
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
r = await daoFactory.newDAO(root);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
acl = getContract('ACL').at(await dao.acl());
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//create dao mamnager permission for coin owner
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await acl.createPermission(
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
root,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
dao.address,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await dao.APP_MANAGER_ROLE(),
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
root,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
{ from: root }
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//get new app instance from DAO
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
const receipt = await dao.newAppInstance(
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'0x1234',
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
(await Contributor.new()).address,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
0x0,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
false,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
{ from: root }
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
contributor = Contributor.at(
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//apps id
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let appsId = [];
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
appsId[0] = namehash("kredits-contribution");
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
appsId[1] = namehash("kredits-contributor");
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
appsId[2] = namehash("kredits-proposal");
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
appsId[3] = namehash("kredits-token");
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//init contributor (app)
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.initialize(root, appsId);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
//create manage contributors role
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await acl.createPermission(
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
root,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
contributor.address,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.MANAGE_CONTRIBUTORS_ROLE(),
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
root,
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
{ from: root }
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
before(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
id = await contributor.coreContributorsCount();
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
oldAccount = root;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
newAccount = member1;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
hashDigest = '0x1000000000000000000000000000000000000000000000000000000000000000';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
hashFunction = 1;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
hashSize = 1;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
||||
describe("Owner default space permissions", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it('check owner is token issuer', async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let manageContributorPermission = await acl.hasPermission(root, contributor.address, await contributor.MANAGE_CONTRIBUTORS_ROLE());
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(manageContributorPermission, true);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it('update contributor account', async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorAccount(id.toNumber(), oldAccount, newAccount);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let contributorId = await contributor.getContributorIdByAddress(oldAccount);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(contributorId.toNumber(), 0);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
||||
describe("Add contributor", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let account = root;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashDigest = '0x0';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashFunction = 0;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashSize = 0;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when add contributor from an address that does not have permission", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'sender does not have permission';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it('add contributor', async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let contributorCount = await contributor.coreContributorsCount();
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.addContributor(account, hashDigest, hashFunction, hashSize);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(await contributor.addressExists(account), true);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let contributorCountAfter = await contributor.coreContributorsCount();
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(await contributorCountAfter.toNumber(), parseInt(contributorCount)+1);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when add contributor with an address that already exist", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'address already exist';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when update contributor account from address that does not have permission", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorAccount(id.toNumber(), oldAccount, newAccount, {from: member1});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'sender does not have permission';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
||||
describe("Update contributor", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let id;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let oldAccount;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let newAccount;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashDigest;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashFunction;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let hashSize;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
before(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
id = await contributor.coreContributorsCount();
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
oldAccount = root;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
newAccount = member1;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
hashDigest = '0x1000000000000000000000000000000000000000000000000000000000000000';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
hashFunction = 1;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
hashSize = 1;
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it('update contributor account', async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorAccount(id.toNumber(), oldAccount, newAccount);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let contributorId = await contributor.getContributorIdByAddress(oldAccount);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
// eslint-disable-next-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(contributorId.toNumber(), 0);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when update contributor account from address that does not have permission", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorAccount(id.toNumber(), oldAccount, newAccount, {from: member1});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'sender does not have permission';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when update contributor account that does not exist", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorAccount(id.toNumber(), accounts[3], newAccount);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'contributor does not exist';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when update contributor account with address(0)", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorAccount(id.toNumber(), oldAccount, ZERO_ADDR);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'contributor does not exist';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it('update contributor profile hash', async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorProfileHash(id.toNumber(), hashDigest, hashFunction, hashSize);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let contributorProfile = await contributor.contributors(id.toNumber());
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(hashDigest, contributorProfile[1]); // eslint-disable-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(hashFunction, contributorProfile[2].toNumber()); // eslint-disable-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(hashSize, contributorProfile[3].toNumber()); // eslint-disable-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when update contributor profile hash from address that does not have permission", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorProfileHash(id.toNumber(), hashDigest, hashFunction, hashSize, {from: member1});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'sender does not have permission';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when update contributor account that does not exist", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorAccount(id.toNumber(), accounts[3], newAccount);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'contributor does not exist';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when update contributor account with address(0)", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorAccount(id.toNumber(), oldAccount, ZERO_ADDR);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'contributor does not exist';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it('update contributor profile hash', async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorProfileHash(id.toNumber(), hashDigest, hashFunction, hashSize);
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
let contributorProfile = await contributor.contributors(id.toNumber());
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(hashDigest, contributorProfile[1]); // eslint-disable-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(hashFunction, contributorProfile[2].toNumber()); // eslint-disable-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
assert.equal(hashSize, contributorProfile[3].toNumber()); // eslint-disable-line no-undef
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
it("should revert when update contributor profile hash from address that does not have permission", async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
return assertRevert(async () => {
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
await contributor.updateContributorProfileHash(id.toNumber(), hashDigest, hashFunction, hashSize, {from: member1});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
'sender does not have permission';
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
});
|
||||
|
||||
|
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
we should be able to use the namehash from ethers: we should be able to use the namehash from ethers:
`const namehash = require('ethers').utils.namehash;`
as ethers.js is already a dependency we do not need to add another dependency
cool will change that cool will change that
cool will change that cool will change that
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
for the ganache script, it is basically the same aragon one, but I changed to Because for the ganache script, it is basically the same aragon one, but I changed
```
run_tests() {
echo "Running tests..."
npx truffle test --network rpc "$@"
}
```
to
```
run_tests() {
echo "Running tests..."
npx aragon contracts test --network rpc "$@"
}
```
Because `npx truffle test --network rpc "$@"` didn't work for me for no reason...
|
||||
we should be able to use the namehash from ethers:
const namehash = require('ethers').utils.namehash;as ethers.js is already a dependency we do not need to add another dependency
we should be able to use the namehash from ethers:
const namehash = require('ethers').utils.namehash;as ethers.js is already a dependency we do not need to add another dependency
cool will change that
cool will change that
for the ganache script, it is basically the same aragon one, but I changed
to
Because
npx truffle test --network rpc "$@"didn't work for me for no reason...for the ganache script, it is basically the same aragon one, but I changed
to
Because
npx truffle test --network rpc "$@"didn't work for me for no reason...