added compute

example/src/App.tsx

@@ -15,6 +15,13 @@ function App() {
     nodeUri: `http://localhost:8545`,
     factoryAddress: '0x2fC1fd21cb222Dc180Ef817dE4c426fd9230b5A5'
   } as Config
+
+  const configRinkeby = {
+    metadataStoreUri: 'https://aquarius.rinkeby.v3.dev-ocean.com',
+    providerUri: 'https://provider.rinkeby.v3.dev-ocean.com',
+    nodeUri: `https://rinkeby.infura.io/a983b53583044593956054de049922fd`,
+    factoryAddress: '0xB9d406D24B310A7D821D0b782a36909e8c925471'
+  } as Config
   const init = async () => {}
   useEffect(() => {
     init()
@@ -22,7 +29,7 @@ function App() {
 
   return (
     <div className="app">
-      <OceanProvider config={config}>
+      <OceanProvider config={configRinkeby}>
         <div className="container">
           <div>
             <Wallet />

example/src/ConsumeDdo.tsx

@@ -15,8 +15,9 @@ export function ConsumeDdo() {
 
   const consumeDid = async () => {
     if (did === undefined) return
+    const ddo = await ocean.assets.resolve(did)
 
-    await consume(did, 'access')
+    await consume(did, ddo.dataToken, 'access')
   }
 
   const handleChange = (e: any) => {

example/src/Publish.tsx

@@ -32,7 +32,9 @@ export function Publish() {
   const marketAddress = '0x4D156A2ef69ffdDC55838176C6712C90f60a2285'
 
   const publishAsset = async () => {
-    const ddo = await publish(asset as Metadata, '4', marketAddress)
+    const ddo = await publish(asset as Metadata, '4', marketAddress, [
+      { serviceType: 'access', cost: '1' }
+    ])
     console.log(ddo)
     setDdo(ddo)
   }

src/hooks/index.ts

@@ -1,3 +1,4 @@
 export * from './useConsume'
 export * from './useMetadata'
 export * from './usePublish'
+export * from './useCompute'

src/hooks/useCompute/ComputeOptions.ts

@@ -0,0 +1,28 @@
+export interface ComputeValue {
+  entrypoint: string
+  image: string
+  tag: string
+}
+export interface ComputeOption {
+  name: string
+  value: ComputeValue
+}
+
+export const computeOptions: ComputeOption[] = [
+  {
+    name: 'nodejs',
+    value: {
+      entrypoint: 'node $ALGO',
+      image: 'node',
+      tag: '10'
+    }
+  },
+  {
+    name: 'python3.7',
+    value: {
+      entrypoint: 'python $ALGO',
+      image: 'oceanprotocol/algo_dockers',
+      tag: 'python-panda'
+    }
+  }
+]

src/hooks/useCompute/index.ts

@@ -0,0 +1,2 @@
+export * from './useCompute'
+export * from './ComputeOptions'

src/hooks/useCompute/useCompute.ts

@@ -0,0 +1,107 @@
+import { useState } from 'react'
+import { useOcean } from '../../providers'
+import { ComputeValue } from './ComputeOptions'
+import { feedback } from './../../utils'
+import { DID, Logger } from '@oceanprotocol/lib'
+import { MetadataAlgorithm } from '@oceanprotocol/lib/dist/node/ddo/interfaces/MetadataAlgorithm'
+
+interface UseCompute {
+  compute: (
+    did: string,
+    computeServiceIndex: number,
+    dataTokenAddress: string,
+    algorithmRawCode: string,
+    computeContainer: ComputeValue
+  ) => Promise<void>
+  computeStep?: number
+  computeStepText?: string
+  computeError?: string
+  isLoading: boolean
+}
+
+// TODO: customize for compute
+export const computeFeedback: { [key in number]: string } = {
+  ...feedback,
+  4: '3/3 Access granted. Starting job...'
+}
+const rawAlgorithmMeta: MetadataAlgorithm = {
+  rawcode: `console.log('Hello world'!)`,
+  format: 'docker-image',
+  version: '0.1',
+  container: {
+    entrypoint: '',
+    image: '',
+    tag: ''
+  }
+}
+
+function useCompute(): UseCompute {
+  const { ocean, account, accountId, config } = useOcean()
+  const [computeStep, setComputeStep] = useState<number | undefined>()
+  const [computeStepText, setComputeStepText] = useState<string | undefined>()
+  const [computeError, setComputeError] = useState<string | undefined>()
+  const [isLoading, setIsLoading] = useState(false)
+
+  function setStep(index: number) {
+    setComputeStep(index)
+    setComputeStepText(computeFeedback[index])
+  }
+
+  async function compute(
+    did: string,
+    computeService: any,
+    dataTokenAddress: string,
+    algorithmRawCode: string,
+    computeContainer: ComputeValue
+  ): Promise<void> {
+    if (!ocean || !account) return
+
+    setComputeError(undefined)
+
+    try {
+      setIsLoading(true)
+      setStep(0)
+      rawAlgorithmMeta.container = computeContainer
+      rawAlgorithmMeta.rawcode = algorithmRawCode
+
+      const output = {}
+      const order = await ocean.compute.order(
+        accountId,
+        did,
+        computeService.index,
+        undefined,
+        rawAlgorithmMeta
+      )
+
+      const computeOrder = JSON.parse(order)
+      const tokenTransfer = await ocean.datatokens.transfer(
+        computeOrder.dataToken,
+        computeOrder.to,
+        String(computeOrder.numTokens),
+        computeOrder.from
+      )
+      const response = await ocean.compute.start(
+        did,
+        (tokenTransfer as any).transactionHash,
+        dataTokenAddress,
+        account,
+        undefined,
+        rawAlgorithmMeta,
+        output,
+        computeService.index,
+        computeService.type
+      )
+    } catch (error) {
+      Logger.error(error)
+      setComputeError(error.message)
+    } finally {
+      setComputeStep(undefined)
+      setIsLoading(false)
+    }
+  }
+
+  return { compute, computeStep, computeStepText, computeError, isLoading }
+}
+
+export { useCompute, UseCompute }
+export default UseCompute

src/hooks/useConsume/useConsume.ts

@@ -5,7 +5,11 @@ import { DID, Logger } from '@oceanprotocol/lib'
 import { ServiceType } from '@oceanprotocol/lib/dist/node/ddo/interfaces/Service'
 
 interface UseConsume {
-  consume: (did: DID | string, serviceType: ServiceType) => Promise<void>
+  consume: (
+    did: DID | string,
+    dataTokenAddress: string,
+    serviceType: ServiceType
+  ) => Promise<void>
   consumeStep?: number
   consumeStepText?: string
   consumeError?: string
@@ -31,15 +35,17 @@ function useConsume(): UseConsume {
     setConsumeStep(index)
     setConsumeStepText(consumeFeedback[index])
   }
-  async function consume(did: string, serviceType: ServiceType): Promise<void> {
+  async function consume(
+    did: string,
+    dataTokenAddress: string,
+    serviceType: ServiceType = 'access'
+  ): Promise<void> {
     if (!ocean || !account) return
     setIsLoading(true)
     setConsumeError(undefined)
 
     try {
       setStep(0)
-      const ddo = await ocean.metadatastore.retrieveDDO(did)
-      Logger.log('ddo retrieved', ddo)
       setStep(1)
       const order = await ocean.assets.order(did, serviceType, accountId)
       Logger.log('order created', order)
@@ -58,7 +64,7 @@ function useConsume(): UseConsume {
       await ocean.assets.download(
         did,
         (tokenTransfer as any).transactionHash,
-        ddo.dataToken,
+        dataTokenAddress,
         account,
         ''
       )

src/hooks/usePublish/ServiceConfig.ts

@@ -0,0 +1,5 @@
+import { ServiceType } from '@oceanprotocol/lib/dist/node/ddo/interfaces/Service'
+export interface ServiceConfig {
+  serviceType: ServiceType
+  cost: string
+}

src/hooks/usePublish/index.ts

@@ -1 +1,2 @@
 export * from './usePublish'
+export * from './ServiceConfig'

src/hooks/usePublish/usePublish.ts

@@ -2,14 +2,18 @@ import { useEffect } from 'react'
 import { DDO, Metadata, DataTokens, Logger } from '@oceanprotocol/lib'
 import { useOcean } from '../../providers'
 import ProviderStatus from '../../providers/OceanProvider/ProviderStatus'
-import { Service } from '@oceanprotocol/lib/dist/node/ddo/interfaces/Service'
+import {
+  Service,
+  ServiceType
+} from '@oceanprotocol/lib/dist/node/ddo/interfaces/Service'
+import { ServiceConfig } from './ServiceConfig'
 
 interface UsePublish {
   publish: (
     asset: Metadata,
     tokensToMint: string,
     marketAddress: string,
-    cost?: string
+    serviceConfigs: ServiceConfig[]
   ) => Promise<DDO>
   mint: (tokenAddress: string, tokensToMint: string) => void
 }
@@ -30,36 +34,30 @@ function usePublish(): UsePublish {
     asset: Metadata,
     tokensToMint: string,
     marketAddress: string,
-    cost = '1'
+    serviceConfigs: ServiceConfig[]
   ): Promise<DDO> {
     if (status !== ProviderStatus.CONNECTED) return
 
-    const datatoken = createDataToken()
-
-    Logger.log('datatokens created', datatoken)
     Logger.log('ocean dt', ocean.datatokens)
     const data = { t: 1, url: config.metadataStoreUri }
     const blob = JSON.stringify(data)
-    const tokenAddress = await datatoken.create(blob, accountId)
+    const tokenAddress = await ocean.datatokens.create(blob, accountId)
-    Logger.log('datatoken created', datatoken)
+    Logger.log('datatoken created', tokenAddress)
     Logger.log('tokens to mint', tokensToMint)
 
-    await mint(tokenAddress, tokensToMint, datatoken)
+    await mint(tokenAddress, tokensToMint)
 
     Logger.log('giving allowance to ', marketAddress)
-    await giveMarketAllowance(
+    await giveMarketAllowance(tokenAddress, marketAddress, tokensToMint)
-      tokenAddress,
-      marketAddress,
-      tokensToMint,
-      datatoken
-    )
     Logger.log('tokenAddress created', tokenAddress)
     const publishedDate = new Date(Date.now()).toISOString().split('.')[0] + 'Z'
     const timeout = 0
-    let services: Service[] = []
+    const services: Service[] = []
-    const price = datatoken.toWei(cost)
+
-    switch (asset.main.type) {
+    serviceConfigs.forEach(async (serviceConfig) => {
-      case 'dataset': {
+      const price = ocean.datatokens.toWei(serviceConfig.cost)
+      switch (serviceConfig.serviceType) {
+        case 'access': {
           const accessService = await ocean.assets.createAccessServiceAttributes(
             account,
             price,
@@ -67,13 +65,21 @@ function usePublish(): UsePublish {
             timeout
           )
           Logger.log('access service created', accessService)
-        services = [accessService]
+          services.push(accessService)
           break
         }
-      case 'algorithm': {
+        case 'compute': {
+          const computeService = await ocean.assets.createAccessServiceAttributes(
+            account,
+            price,
+            publishedDate,
+            0
+          )
+          services.push(computeService)
           break
         }
       }
+    })
 
     const ddo = await ocean.assets.create(
       asset,
@@ -85,24 +91,22 @@ function usePublish(): UsePublish {
     return ddo
   }
 
-  async function mint(
+  async function mint(tokenAddress: string, tokensToMint: string) {
-    tokenAddress: string,
-    tokensToMint: string,
-    datatoken?: DataTokens
-  ) {
-    if (datatoken === undefined) datatoken = createDataToken()
     Logger.log('mint function', tokenAddress, accountId)
-    await datatoken.mint(tokenAddress, accountId, tokensToMint)
+    await ocean.datatokens.mint(tokenAddress, accountId, tokensToMint)
   }
 
   async function giveMarketAllowance(
     tokenAddress: string,
     marketAddress: string,
-    tokens: string,
+    tokens: string
-    datatoken?: DataTokens
   ) {
-    if (datatoken === undefined) datatoken = createDataToken()
+    await ocean.datatokens.approve(
-    await datatoken.approve(tokenAddress, marketAddress, tokens, accountId)
+      tokenAddress,
+      marketAddress,
+      tokens,
+      accountId
+    )
   }
 
   return {

src/providers/OceanProvider/OceanProvider.tsx

@@ -40,7 +40,9 @@ function OceanProvider({
 
   function init() {
     Logger.log('Ocean Provider init')
-    window.ethereum.autoRefreshOnNetworkChange = false
+    window &&
+      window.ethereum &&
+      (window.ethereum.autoRefreshOnNetworkChange = false)
   }
 
   // On mount setup Web3Modal instance