3eb53ee6af | ||
---|---|---|
bin | ||
boilerplate | ||
demo | ||
docs | ||
js | ||
lib | ||
old_test | ||
test | ||
test_app | ||
.codeclimate.yml | ||
.gitignore | ||
.npmignore | ||
.nycrc | ||
.travis.yml | ||
CONTRIBUTING.md | ||
Class Hierarchy.mmd | ||
Gruntfile.coffee | ||
LICENSE | ||
README.md | ||
package.json | ||
script_test.js | ||
webpack.config.js |
README.md
What is Embark
Embark is a framework that allows you to easily develop and deploy Decentralized Applications (DApps).
A Decentralized Application is a serverless html5 application that uses one or more decentralized technologies.
Embark currently integrates with EVM blockchains (Ethereum), Decentralized Storages (IPFS), and Decentralized communication platforms (Whisper and Orbit). Swarm is supported for deployment.
With Embark you can:
Blockchain (Ethereum)
- Automatically deploy contracts and make them available in your JS code. Embark watches for changes, and if you update a contract, Embark will automatically redeploy the contracts (if needed) and the dapp.
- Contracts are available in JS with Promises.
- Do Test Driven Development with Contracts using Javascript.
- Keep track of deployed contracts; deploy only when truly needed.
- Manage different chains (e.g testnet, private net, livenet)
- Easily manage complex systems of interdependent contracts.
Decentralized Storage (IPFS)
- Easily Store & Retrieve Data on the DApp through EmbarkJS. Including uploading and retrieving files.
- Deploy the full application to IPFS or Swarm.
Decentralized Communication (Whisper, Orbit)
- Easily send/receive messages through channels in P2P through Whisper or Orbit.
Web Technologies
- Integrate with any web technology including React, Foundation, etc..
- Use any build pipeline or tool you wish, including grunt, gulp and webpack.
Table of Contents
- Installation
- Usage Demo
- Dashboard
- Creating a new DApp
- Libraries and APIs available
- Using and Configuring Contracts
- EmbarkJS
- EmbarkJS - Storage (IPFS)
- EmbarkJS - Communication (Whisper/Orbit)
- Testing Contracts
- Working with different chains
- Custom Application Structure
- Deploying to IPFS
- Extending Functionality with Plugins
- Donations
Installation
Requirements: geth (1.6.5 or higher recommended, 1.6.0 or lower for whisper support), node (6.9.1 or higher is recommended) and npm Optional: testrpc (3.0 or higher) if using the simulator or the test functionality. Further: depending on the dapp stack you choose: IPFS
$ npm -g install embark
# If you plan to use the simulator instead of a real ethereum node.
$ npm -g install ethereumjs-testrpc
See Complete Installation Instructions.
updating from Embark 1
Embark's npm package has changed from embark-framework
to embark
, this sometimes can create conflicts. To update first uninstall embark-framework 1 to avoid any conflicts. npm uninstall -g embark-framework
then npm install -g embark
Usage - Demo
You can easily create a sample working DApp with the following:
$ embark demo
$ cd embark_demo
You can run a REAL ethereum node for development purposes:
$ embark blockchain
Alternatively, to use an ethereum rpc simulator simply run:
$ embark simulator
By default Embark blockchain will mine a minimum amount of ether and will only mine when new transactions come in. This is quite useful to keep a low CPU. The option can be configured at config/blockchain.json
. Note that running a real node requires at least 2GB of free ram, please take this into account if running it in a VM.
Then, in another command line:
$ embark run
This will automatically deploy the contracts, update their JS bindings and deploy your DApp to a local server at http://localhost:8000
Note that if you update your code, it will automatically be re-deployed, contracts included. There is no need to restart embark, refreshing the page on the browser will do.
Dashboard
Embark 2 comes with a terminal dashboard.
The dashboard will tell you the state of your contracts, the environment you are using, and what Embark is doing at the moment.
available services
Available Services will display the services available to your dapp in green. If a service is down, then it will be displayed in red.
logs and console
There is a console at the bottom which can be used to interact with contracts or with Embark itself. Type help
to see a list of available commands. More commands will be added with each version of Embark.
Creating a new DApp
If you want to create a blank new app:
$ embark new AppName
$ cd AppName
DApp Structure
app/
|___ contracts/ #solidity or serpent contracts
|___ html/
|___ css/
|___ js/
config/
|___ blockchain.json #rpc and blockchain configuration
|___ contracts.json #ethereum contracts configuration
|___ storage.json #ipfs configuration
|___ communication.json #whisper/orbit configuration
|___ webserver.json #dev webserver configuration
test/
|___ #contracts tests
Solidity/Serpent files in the contracts directory will automatically be deployed with Embark run. Changes in any files will automatically be reflected in app, changes to contracts will result in a redeployment and update of their JS Bindings
Libraries and languages available
Embark can build and deploy contracts coded in Solidity. It will make them available on the client side using EmbarkJS and Web3.js.
Further documentation for these can be found below:
Using Contracts
Embark will automatically take care of deployment for you and set all needed JS bindings. For example, the contract below:
# app/contracts/simple_storage.sol
pragma solidity ^0.4.7;
contract SimpleStorage {
uint public storedData;
function SimpleStorage(uint initialValue) {
storedData = initialValue;
}
function set(uint x) {
storedData = x;
}
function get() constant returns (uint retVal) {
return storedData;
}
}
Will automatically be available in Javascript as:
# app/js/index.js
SimpleStorage.set(100);
SimpleStorage.get().then(function(value) { console.log(value.toNumber()) });
SimpleStorage.storedData().then(function(value) { console.log(value.toNumber()) });
You can specify for each contract and environment its gas costs and arguments:
# config/contracts.json
{
"development": {
"gas": "auto",
"contracts": {
"SimpleStorage": {
"args": [
100
]
}
}
}
}
If you are using multiple contracts, you can pass a reference to another contract as $ContractName
, Embark will automatically replace this with the correct address for the contract.
# config/contracts.json
{
...
"development": {
"contracts": {
"SimpleStorage": {
"args": [
100,
"$MyStorage"
]
},
"MyStorage": {
"args": [
"initial string"
]
},
"MyMainContract": {
"args": [
"$SimpleStorage"
]
}
}
}
...
}
You can now deploy many instances of the same contract. e.g
# config/contracts.json
{
"development": {
"contracts": {
"Currency": {
"deploy": false,
"args": [
100
]
},
"Usd": {
"instanceOf": "Currency",
"args": [
200
]
},
"MyCoin": {
"instanceOf": "Currency",
"args": [
200
]
}
}
}
}
...
Contracts addresses can be defined. If an address is defined, Embark uses the defined address instead of deploying the contract.
# config/contracts.json
{
...
"development": {
"contracts": {
"UserStorage": {
"address": "0x123456"
},
"UserManagement": {
"args": [
"$UserStorage"
]
}
}
}
...
}
EmbarkJS
EmbarkJS is a javascript library meant to abstract and facilitate the development of DApps.
promises
methods in EmbarkJS contracts will be converted to promises.
var myContract = new EmbarkJS.Contract({abi: abiObject, address: "0x123"});
myContract.get().then(function(value) { console.log("value is " + value.toNumber) });
events:
myContract.eventName({from: web3.eth.accounts}, 'latest').then(function(event) { console.log(event) });
deployment
Client side deployment will be automatically available in Embark for existing contracts:
SimpleStorage.deploy([args], {options}).then(function(anotherSimpleStorage) {});
or it can be manually definied as
var myContract = new EmbarkJS.Contract({abi: abiObject, code: code});
myContract.deploy([args], {options}).then(function(anotherMyContractObject) {});
so you can define your gas as
myContract.deploy([100, "seconde argument"], {gas: 800000}).then(function(anotherMyContractObject) {});
EmbarkJS - Storage
initialization
The current available storage is IPFS. It can be initialized as
EmbarkJS.Storage.setProvider('ipfs',{server: 'localhost', port: '5001'})
Saving Text
EmbarkJS.Storage.saveText("hello world").then(function(hash) {});
Retrieving Data/Text
EmbarkJS.Storage.get(hash).then(function(content) {});
Uploading a file
<input type="file">
var input = $("input[type=file"]);
EmbarkJS.Storage.uploadFile(input).then(function(hash) {});
Generate URL to file
EmbarkJS.Storage.getUrl(hash);
note: if not using localhost, the cors needs to be set as ipfs --json API.HTTPHeaders.Access-Control-Allow-Origin '["your-host-name-port"]
EmbarkJS - Communication
initialization
For Whisper:
EmbarkJS.Messages.setProvider('whisper')
For Orbit:
You'll need to use IPFS from master and run it as: ipfs daemon --enable-pubsub-experiment
then set the provider:
EmbarkJS.Messages.setProvider('orbit', {server: 'localhost', port: 5001})
listening to messages
EmbarkJS.Messages.listenTo({topic: ["topic1", "topic2"]}).then(function(message) { console.log("received: " + message); })
sending messages
you can send plain text
EmbarkJS.Messages.sendMessage({topic: "sometopic", data: 'hello world'})
or an object
EmbarkJS.Messages.sendMessage({topic: "sometopic", data: {msg: 'hello world'}})
note: array of topics are considered an AND. In Whisper you can use another array for OR combinations of several topics e.g ["topic1", ["topic2", "topic3"]]
=> topic1 AND (topic2 OR topic 3)
Tests
You can run specs with embark test
, it will run any test files under test/
.
Embark includes a testing lib to rapidly run & test your contracts in a EVM.
# test/simple_storage_spec.js
var assert = require('assert');
var Embark = require('embark');
var EmbarkSpec = Embark.initTests();
var web3 = EmbarkSpec.web3;
describe("SimpleStorage", function() {
before(function(done) {
this.timeout(0);
var contractsConfig = {
"SimpleStorage": {
args: [100]
}
};
EmbarkSpec.deployAll(contractsConfig, done);
});
it("should set constructor value", function(done) {
SimpleStorage.storedData(function(err, result) {
assert.equal(result.toNumber(), 100);
done();
});
});
it("set storage value", function(done) {
SimpleStorage.set(150, function() {
SimpleStorage.get(function(err, result) {
assert.equal(result.toNumber(), 150);
done();
});
});
});
});
Embark uses Mocha by default, but you can use any testing framework you want.
Working with different chains
You can specify which environment to deploy to:
$ embark blockchain livenet
$ embark run livenet
The environment is a specific blockchain configuration that can be managed at config/blockchain.json
# config/blockchain.json
...
"livenet": {
"networkType": "livenet",
"rpcHost": "localhost",
"rpcPort": 8545,
"rpcCorsDomain": "http://localhost:8000",
"account": {
"password": "config/livenet/password"
}
},
...
Structuring Application
Embark is quite flexible and you can configure your own directory structure using embark.json
# embark.json
{
"contracts": ["app/contracts/**"],
"app": {
"css/app.css": ["app/css/**"],
"images/": ["app/images/**"],
"js/app.js": ["embark.js", "app/js/**"],
"index.html": "app/index.html"
},
"buildDir": "dist/",
"config": "config/",
"plugins": {}
}
Deploying to IPFS and Swarm
To deploy a dapp to IPFS, all you need to do is run a local IPFS node and then run embark upload ipfs
.
If you want to deploy to the livenet then after configuring you account on config/blockchain.json
on the livenet
environment then you can deploy to that chain by specifying the environment embark ipfs livenet
.
To deploy a dapp to SWARM, all you need to do is run a local SWARM node and then run embark upload swarm
.
Plugins
It's possible to extend Embark's functionality with plugins. For example, the following is possible:
- plugin to add support for es6, jsx, coffescript, etc (
embark.registerPipeline
) - plugin to add standard contracts or a contract framework (
embark.registerContractConfiguration
andembark.addContractFile
) - plugin to make some contracts available in all environments for use by other contracts or the dapp itself e.g a Token, a DAO, ENS, etc.. (
embark.registerContractConfiguration
andembark.addContractFile
) - plugin to add a libraries such as react or bootstrap (
embark.addFileToPipeline
) - plugin to specify a particular web3 initialization for special provider uses (
embark.registerClientWeb3Provider
) - plugin to create a different contract wrapper (
embark.registerContractsGeneration
) - plugin to add new console commands (
embark.registerConsoleCommand
) - plugin to add support for another contract language such as viper, LLL, etc (
embark.registerCompiler
)
For more information on how to develop your own plugin, please see the plugin documentation
Donations
If you like Embark, please consider donating to 0x8811FdF0F988f0CD1B7E9DE252ABfA5b18c1cDb1