Kickoff meeting notes

[izqui]

Pre-meeting notes

Goal: Library used by Aragon UI and first- and third-party modules to interact with Aragon contracts.

Implements logic most apps will need to function.

Basic features:

• Installation of organs and apps

• Interaction with MetaOrgan

• Listen and cache events related to app and organ installation.

• Expose API for apps to listen for events (aragon.js will catch syncing state)

• APM support:

  • fetching a dependency
  • parsing the aragon package json
  • finding the factory for the application
  • deploying a new instance
  • getting meta info about already installed apps

• Generic dispatcher:

  • Show info about action (natspec)
  • Bylaws integration for default controls (vote, status, tokenholder). Beware of conditional composable bylaws!
  • plug-in for custom bylaw oracles
  • queue of pending transactions and past transactions
  • sends transaction to the signing provider on user approve

Action items

• APM will live as its own separate codebase, aragon.js will import it and use part of it.
• aragon.js responsibility ends once the transaction payload has been constructed. Signing and broadcasting is done at the correspondent signing provider.
• @onbjerg to explore with desired interface for the module.
• @izqui to add organ and application installed events to aragon-core for aragon.js to cache.

Open challenges

• Application inter-operability: When dispatching an unrelated action, aragon.js detects the action needs a voting. Voting is no longer a native action but an application specific one. To what extent aragon.js creates the voting or 'links' to the Voting app for the voting to happen.
• Application defined bylaws or bylaw oracles: Applications aren't able to define their own type of bylaws (they can use generic ones) in aragon-core right now. Custom bylaws are supported through 'oracle bylaws' in which a certain contract address is asked whether an action is permitted. How do we support this?

[onbjerg]

These are my notes:

Pre-meeting notes

• Aragon.js should be its own package
• Abstract away web3 and other backends (i.e. IPFS)
• Used like a standard "API client" like for REST
• Plug in providers (i.e. web3, signer, IPFS, ...)
• Not sure if apps have a standard-ish interface we can use to easily add multiple apps/organs

Post-meeting notes

• It should support the APM spec (aragon package manager), but the APM client should be a seperate package and Aragon.js should depend on it
• Aragon.js should provide helper functions for module developers, because apps should be called through the DAO (even though not in DAO context, i.e. apps have their own storage and events)
• Aragon.js should perform checks to see if a transaction will succeed or not, e.g. ACL, and provide pre-flight messages so that the UI can provide contextual information based on the user performing the action
• Caching should be handled by Aragon.js
  • Aragon.js keeps state for the DAO and other things at a current block and tries to catch up with the state from the current block continually
• Aragon.js creates raw unsigned transactions, and an external signer signs the transaction (because we want to support multiple signers, e.g. uPort, in-memory, ...)
• The external signer will live in its own package and will probably not be a dependency of Aragon.js, but rather a dependency of the dapp
• We need to give special meaning to some apps (e.g. bylaws and voting) because they constitute permissions for all apps (needed in the pre-flight step)

Steps

• Read current Aragon dapp code
• Document contracts (web3 interface)
• Write some usage examples
• Flesh out initial functionality

[izqui]

Closing as it is no longer relevant