From 9a5fdb458ebbbbcff8a0eeb42957f86ca3b57799 Mon Sep 17 00:00:00 2001 From: Alex Coseru Date: Fri, 22 May 2020 14:31:39 +0300 Subject: [PATCH] Update README_marketplace_flow.md --- README_marketplace_flow.md | 121 +++++++++++++++++++++++++++++-------- 1 file changed, 97 insertions(+), 24 deletions(-) diff --git a/README_marketplace_flow.md b/README_marketplace_flow.md index 870c26fa..eafd8028 100644 --- a/README_marketplace_flow.md +++ b/README_marketplace_flow.md @@ -1,6 +1,23 @@ + Alice -> Alice: create new ID + Alice -> Alice: define PublisherService in DDO + Alice -> Alice : initialize MetaData with services + Alice -> Library: publish asset + Library -> Provider: get ID for URL + Provider -> Library : URL + Library -> Alice: sign DeployDToken transaction + Alice -> Library: sign DeployDToken + Library -> contracts: DeployDToken(blob) + contracts -> Library : Deployed: (0x12345) + Library -> Library: update MetaData ERC20 with DT address +else import MetaData + Alice -> Library: import MetaData + + + # ocean-lib + `ocean-lib-js` is a Javascript/Typescript library to privately & securely publish, exchange, and consume data. With it, you can: * **Publish** data services: static data, streaming data, or compute-to-data. Every data service gets its own [ERC20](https://github.com/ethereum/EIPs/blob/7f4f0377730f5fc266824084188cc17cf246932e/EIPS/eip-20.md) token. * **Mint** data tokens for a given data service @@ -21,7 +38,7 @@ const { Ocean, Logger } = require('@oceanprotocol/lib') # Quickstart -This section describes a flow with the simplest transfer of value, for static data. +This section describes a marketplace flow with multiple services Here's the steps. 1. Alice publishes a dataset (= publishes a datatoken contract) @@ -32,39 +49,64 @@ Here's the steps. Let's go through each of these in detail. -## 1. Alice publishes a dataset (= publishes a datatoken contract) +## 1. Alice hosts the dataset + +A locally providerService ,metadatastore and marketplace are required: + +Run the providerService and metadatastore: +``` +docker run @oceanprotocol/provider-py:latest +docker run @oceanprotocol/aquarius:latest +docker run @oceanprotocol/marketplace:latest +``` + + +## 2. Alice publishes a dataset (= publishes a datatoken contract) For now, you're Alice:) Let's proceed. ```javascript const { Ocean, Logger } = require('@oceanprotocol/lib') + +const marketPlaceAddress='0x9876' +//Alice's config const config={ network: 'rinkeby', privateKey:'8da4ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f', + metadataStoreURI: 'localhost:5000', + providerUri: 'localhost:8030' } const ocean = Ocean(alice_config) const account = await ocean.accounts.list()[0] -const myToken = ocean.datatoken.create('localhost:8030',account) + + +const myToken = ocean.datatoken.create(config.metadataStoreURI,account) +//Alice allows MarketPlace to transfer 20 DT +myToken.approve(marketPlaceAddress,20) + const dt_address=myToken.getAddress() -console.log(dt_address) + +//create asset 1 +const metaData={ + "did":"did:op:1234", + "owner":"0xaaaaa", + "dtAddress":dt_address, + "name":"Asset1", + "services="[ + { "id":0, "serviceEndpoint":"providerUri", "type":"download", "dtCost":10, "timeout":0, + "files":[{"url":"http://example.net"},{"url":"http://example.com" }] + }, + { "id":1, "type":"compute", "serviceEndpoint":"providerUri", "dtCost":1,"timeout":3600}, + { "id":2, "type":"compute", "serviceEndpoint":"providerUri", "dtCost":2, "timeout":7200 }, + ] +} +//create will encrypt the URLs using publisher and update the ddo before pushing to aquarius +//create will require that metaData.dtAddress is a valid DT Contract address +const asset = ocean.assets.create(metaData,account) +const did = asset.did ``` -## 2. Alice hosts the dataset - -A locally providerService is required, which will serve just one file for this demo. -Let's create the file to be shared: -``` -touch /var/mydata/myFolder1/file -```` - -Run the providerService: -(given that ERC20 contract address from the above is 0x1234) - -``` -ENV DT="{'0x1234':'/var/mydata/myFolder1'}" -docker run @oceanprotocol/provider-py -e CONFIG=DT -``` ## 3. Alice mints 100 tokens @@ -73,10 +115,28 @@ docker run @oceanprotocol/provider-py -e CONFIG=DT myToken.mint(100) ``` -## 4. Alice transfers 1 token to Bob +## 4. Exchange of value : How Bob gets DT +``` + +const bob_config={ + network: 'rinkeby', + privateKey:'1234ef21b864d2cc526dbdb2a120bd2874c36c9d0a1fb7f8c63d7f7a8b41de8f' + marketPlaceUri: 'localhost:3000' +} +const bob_ocean = Ocean(bob_config) +const bob_account = await bob_ocean.accounts.list()[0] + +const asset = ocean.assets.resolve(did) +const serviceIndex = assets.findServiceByType('compute') +const num_dt_needed = assets.getDtCost(serviceIndex) +//Bob need to buy num_dt_needed . DTAddress = asset.dtAddress + +const {price, currency } = ocean.marketplace.getPrice(num_dt_needed,asset.dtAddress) +bob_account.approve(price, currency, marketPlaceAddress) +ocean.marketplace.buy(num_dt_needed,asset.dtAddress) + + -```javascript -myToken.transfer(1,BobAddress) ``` ## 5. Bob consumes dataset @@ -94,8 +154,21 @@ const bob_ocean = Ocean(bob_config) const account = await bob_ocean.accounts.list()[0] -const asset=bob_ocean.assets.get(dt_address) -const file=asset.download(account) +const asset = ocean.assets.getFromDID(did) +const serviceIndex = assets.findServiceByType('compute') + +export const rawAlgoMeta = { + rawcode: `console.log('Hello world'!)`, + format: 'docker-image', + version: '0.1', + container: { + entrypoint: 'node $ALGO', + image: 'node', + tag: '10' + } +} + +const computeJob=asset.StartCompute(serviceIndex, rawAlgoMeta, account) ```