Add publish tasks to service marketplace

systemservices/marketplace/mesg.yml

@@ -160,7 +160,7 @@ tasks:
         description: ""
         data: *service
       error: *outputError
-  publishServiceVersion:
+  preparePublishServiceVersion:
     name: ""
     description: ""
     inputs:
@@ -229,26 +229,49 @@ tasks:
             name: "Data"
             description: "The data of the transaction."
             type: String
-  createServiceOffer:
+  publishPublishServiceVersion:
     name: ""
     description: ""
     inputs:
-      sid: *sid
-      price:
-        name: ""
-        description: ""
-        type: String
-      duration:
+      signedTransaction: &signedTransaction
         name: ""
         description: ""
         type: String
+    outputs:
+      error: *outputError
+      success:
+        data:
+          sid: *sid
+          versionHash: *versionHash
+          manifest: *manifest
+          manifestProtocol: *manifestProtocol
+  prepareCreateServiceOffer:
+    name: ""
+    description: ""
+    inputs:
+      sid: *sid
+      price: *price
+      duration: *duration
       from: *inputFrom
       gas: *inputGas
       gasPrice: *inputGasPrice
     outputs:
       error: *outputError
       success: *outputTransaction
-  purchase:
+  publishCreateServiceOffer:
+    name: ""
+    description: ""
+    inputs:
+      signedTransaction: *signedTransaction
+    outputs:
+      error: *outputError
+      success:
+        data:
+          sid: *sid
+          offerIndex: *offerIndex
+          price: *price
+          duration: *duration
+  preparePurchase:
     name: ""
     description: ""
     inputs:
@@ -265,20 +288,23 @@ tasks:
             repeated: true
             type: Object
             object: *transaction
-  sendSignedTransaction:
+  publishPurchase:
     name: ""
     description: ""
     inputs:
-      signedTransaction:
-        name: ""
-        description: ""
-        type: String
+      signedTransactions:
+        <<: *signedTransaction
+        repeated: true
     outputs:
       error: *outputError
       success:
         data:
-          receipt:
-            type: Object
+          sid: *sid
+          offerIndex: *offerIndex
+          purchaser: *purchaser
+          price: *price
+          duration: *duration
+          expire: *expire
   isAuthorized:
     name: ""
     description: ""

systemservices/marketplace/src/contracts/offer.ts

@@ -6,21 +6,20 @@ import { fromUnit, parseTimestamp, asciiToHex } from "./utils";
 const getServiceOffers = async (contract: Marketplace, sid: string): Promise<Offer[]> => {
   const sidHex = asciiToHex(sid)
   if (!await contract.methods.isServiceExist(sidHex).call()) {
-    return []
+    throw new Error(`service ${sid} does not exist`)
   }
   const offersLength = new BigNumber(await contract.methods.serviceOffersLength(sidHex).call())
-  const offersPromise: Promise<Offer|undefined>[] = []
+  const offersPromise: Promise<Offer>[] = []
   for (let j = new BigNumber(0); offersLength.isGreaterThan(j); j = j.plus(1)) {
     offersPromise.push(getServiceOffer(contract, sid, j))
   }
-  const offers = await Promise.all(offersPromise)
-  return offers.filter(offer => offer !== undefined) as Offer[]
+  return Promise.all(offersPromise)
 }
 
-const getServiceOffer = async (contract: Marketplace, sid: string, offerIndex: BigNumber): Promise<Offer|undefined> => {
+const getServiceOffer = async (contract: Marketplace, sid: string, offerIndex: BigNumber): Promise<Offer> => {
   const sidHex = asciiToHex(sid)
   if (!await contract.methods.isServiceOfferExist(sidHex, offerIndex.toString()).call()) {
-    return
+    throw new Error(`offer for service '${sid}' with offer index '${offerIndex.toString()}' does not exist`)
   }
   const offer = await contract.methods.serviceOffer(sidHex, offerIndex.toString()).call()
   return {

systemservices/marketplace/src/contracts/parseEvents.ts

@@ -1,4 +1,4 @@
-import { hexToAscii, fromUnit, parseTimestamp } from "./utils";
+import { hexToAscii, fromUnit, parseTimestamp, hexToHash } from "./utils";
 
 const serviceCreated = (data: any) => ({
   sid: hexToAscii(data.sid),
@@ -29,7 +29,7 @@ const servicePurchased = (data: any) => ({
 })
 const serviceVersionCreated = (data: any) => ({
     sid: hexToAscii(data.sid),
-    versionHash: data.versionHash,
+    versionHash: hexToHash(data.versionHash),
     manifest: hexToAscii(data.manifest),
     manifestProtocol: hexToAscii(data.manifestProtocol),
 })

systemservices/marketplace/src/contracts/purchase.ts

@@ -6,26 +6,25 @@ import { parseTimestamp, asciiToHex } from "./utils";
 const getServicePurchases = async (contract: Marketplace, sid: string): Promise<Purchase[]> => {
   const sidHex = asciiToHex(sid)
   if (!await contract.methods.isServiceExist(sidHex).call()) {
-    return []
+    throw new Error(`service ${sid} does not exist`)
   }
   const purchasesLength = new BigNumber(await contract.methods.servicePurchasesLength(sidHex).call())
-  const purchasesPromise: Promise<Purchase|undefined>[] = []
+  const purchasesPromise: Promise<Purchase>[] = []
   for (let j = new BigNumber(0); purchasesLength.isGreaterThan(j); j = j.plus(1)) {
     purchasesPromise.push(getServicePurchaseWithIndex(contract, sid, j))
   }
-  const purchases = await Promise.all(purchasesPromise)
-  return purchases.filter(purchase => purchase !== undefined) as Purchase[]
+  return Promise.all(purchasesPromise)
 }
 
-const getServicePurchaseWithIndex = async (contract: Marketplace, sid: string, purchaseIndex: BigNumber): Promise<Purchase|undefined> => {
+const getServicePurchaseWithIndex = async (contract: Marketplace, sid: string, purchaseIndex: BigNumber): Promise<Purchase> => {
   const purchaser = await contract.methods.servicePurchaseAddress(asciiToHex(sid), purchaseIndex.toString()).call()
   return getServicePurchase(contract, sid, purchaser)
 }
 
-const getServicePurchase = async (contract: Marketplace, sid: string, purchaser: string): Promise<Purchase|undefined> => {
+const getServicePurchase = async (contract: Marketplace, sid: string, purchaser: string): Promise<Purchase> => {
   const sidHex = asciiToHex(sid)
   if (!await contract.methods.isServicesPurchaseExist(sidHex, purchaser).call()) {
-    return
+    throw new Error(`purchase for service '${sid}' with purchase '${purchaser}' does not exist`)
   }
   const purchase = await contract.methods.servicePurchase(sidHex, purchaser).call()
   return {

systemservices/marketplace/src/contracts/service.ts

@@ -8,24 +8,23 @@ import { hexToAscii, parseTimestamp, asciiToHex } from "./utils";
 
 const getAllServices = async (contract: Marketplace): Promise<Service[]> => {
   const servicesLength = new BigNumber(await contract.methods.servicesLength().call())
-  const servicesPromise: Promise<Service|undefined>[] = []
+  const servicesPromise: Promise<Service>[] = []
   for (let i = new BigNumber(0); servicesLength.isGreaterThan(i); i = i.plus(1)) {
     servicesPromise.push(getServiceWithIndex(contract, i))
   }
-  const services = await Promise.all(servicesPromise)
-  return services.filter(service => service !== undefined) as Service[]
+  return Promise.all(servicesPromise)
 }
 
-const getServiceWithIndex = async (contract: Marketplace, serviceIndex: BigNumber): Promise<Service|undefined> => {
+const getServiceWithIndex = async (contract: Marketplace, serviceIndex: BigNumber): Promise<Service> => {
   const sidHashed = await contract.methods.servicesList(serviceIndex.toString()).call()
   const service = await contract.methods.services(sidHashed).call()
   return getService(contract, hexToAscii(service.sid))
 }
 
-const getService = async (contract: Marketplace, sid: string): Promise<Service|undefined> => {
+const getService = async (contract: Marketplace, sid: string): Promise<Service> => {
   const sidHex = asciiToHex(sid)
   if (!await contract.methods.isServiceExist(sidHex).call()) {
-    return
+    throw new Error(`service ${sid} does not exist`)
   }
   const service = await contract.methods.service(sidHex).call()
   const [ versions, offers, purchases ] = await Promise.all([

systemservices/marketplace/src/contracts/utils.ts

@@ -3,6 +3,8 @@ import BigNumber from 'bignumber.js';
 import Contract from 'web3/eth/contract';
 import { TaskInputs } from 'mesg-js/lib/service';
 import { Tx } from 'web3/eth/types';
+import { ABIDefinition } from 'web3/eth/abi';
+import { Log } from 'web3/types';
 const base58 = require('base-x')('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz')
 
 BigNumber.config({ EXPONENTIAL_AT: 100 })
@@ -51,16 +53,40 @@ const createTransactionTemplate = (
   inputs: TaskInputs,
   data: string,
   shiftNonce?: number
-) => {
-  return {
-    chainID: chainID,
-    to: contract.options.address,
-    nonce: (await web3.eth.getTransactionCount(inputs.from)) + (shiftNonce || 0),
-    gas: inputs.gas || defaultGas,
-    gasPrice: inputs.gasPrice || defaultGasPrice,
-    value: '0',
-    data: data
-  }
+) => ({
+  chainID: chainID,
+  to: contract.options.address,
+  nonce: (await web3.eth.getTransactionCount(inputs.from)) + (shiftNonce || 0),
+  gas: inputs.gas || defaultGas,
+  gasPrice: inputs.gasPrice || defaultGasPrice,
+  value: '0',
+  data: data
+})
+
+const extractEventFromLogs = (web3: Web3, contract: Contract, eventName: string, logs: Log[]): any => {
+  const abi = findInAbi(contract.options.jsonInterface, eventName)
+  const log = findInLogs(web3, abi, logs)
+  return decodeLog(web3, abi, log)
+}
+
+const findInLogs = (web3: Web3, abi: ABIDefinition, logs: Log[]) => {
+  const eventSignature = web3.eth.abi.encodeEventSignature(abi)
+  const index = logs.findIndex(log => log.topics[0] === eventSignature)
+  if (index === -1) throw new Error(`Did not find event '${abi.name}' in logs`)
+  return logs[index]
+}
+
+const decodeLog = (web3: Web3, abi: ABIDefinition, log: Log): any => {
+  // Remove first element because event is non-anonymous
+  // https://web3js.readthedocs.io/en/1.0/web3-eth-abi.html#decodelog
+  if (abi.anonymous === false) log.topics.splice(0, 1)
+  return web3.eth.abi.decodeLog(abi.inputs as object, log.data, log.topics)
+}
+
+const findInAbi = (abi: ABIDefinition[], eventName: string): ABIDefinition => {
+  const index = abi.findIndex(a => a.name === eventName)
+  if (index === -1) throw new Error(`Did not find definition '${eventName}' in abi`)
+  return abi[index]
 }
 
 export {
@@ -74,4 +100,8 @@ export {
   CreateTransaction,
   hashToHex,
   hexToHash,
+  decodeLog,
+  findInAbi,
+  findInLogs,
+  extractEventFromLogs,
 }

systemservices/marketplace/src/contracts/version.ts

@@ -7,26 +7,25 @@ import { getManifest } from "./manifest";
 const getServiceVersions = async (contract: Marketplace, sid: string): Promise<Version[]> => {
   const sidHex = asciiToHex(sid)
   if (!await contract.methods.isServiceExist(sidHex).call()) {
-    return []
+    throw new Error(`service ${sid} does not exist`)
   }
   const versionsLength = new BigNumber(await contract.methods.serviceVersionsLength(sidHex).call())
-  const versionsPromise: Promise<Version|undefined>[] = []
+  const versionsPromise: Promise<Version>[] = []
   for (let j = new BigNumber(0); versionsLength.isGreaterThan(j); j = j.plus(1)) {
     versionsPromise.push(getServiceVersionWithIndex(contract, sid, j))
   }
-  const versions = await Promise.all(versionsPromise)
-  return versions.filter(version => version !== undefined) as Version[]
+  return Promise.all(versionsPromise)
 }
 
-const getServiceVersionWithIndex = async (contract: Marketplace, sid: string, versionIndex: BigNumber): Promise<Version|undefined> => {
+const getServiceVersionWithIndex = async (contract: Marketplace, sid: string, versionIndex: BigNumber): Promise<Version> => {
   const versionHash = hexToHash(await contract.methods.serviceVersionHash(asciiToHex(sid), versionIndex.toString()).call())
   return getServiceVersion(contract, versionHash)
 }
 
-const getServiceVersion = async (contract: Marketplace, versionHash: string): Promise<Version|undefined> => {
+const getServiceVersion = async (contract: Marketplace, versionHash: string): Promise<Version> => {
   const versionHashHex = hashToHex(versionHash)
   if (!await contract.methods.isServiceVersionExist(versionHashHex).call()) {
-    return
+    throw new Error(`version ${versionHash} does not exist`)
   }
   const version = await contract.methods.serviceVersion(versionHashHex).call()
   let manifestData = null

systemservices/marketplace/src/events/index.ts

@@ -43,7 +43,7 @@ export default async (
           }
           eventHandlers[event.event](mesg, event)
         } catch(error) {
-          console.error('An error occurred during processing of an event', event)
+          console.error(`An error occurred during processing of event '${event.event}'.`, error)
         }
       })
     }

systemservices/marketplace/src/tasks/getService.ts

@@ -5,12 +5,6 @@ import { getService } from "../contracts/service";
 export default (contract: Marketplace) => async (inputs: TaskInputs, outputs: TaskOutputs): Promise<void> => {
   try {
     const service = await getService(contract, inputs.sid)
-    if (service === undefined) {
-      return outputs.error({
-        message: 'service with sid ' + inputs.sid + ' does not exist',
-        code: 'notFound',
-      })
-    }
     return outputs.success(service)
   }
   catch (error) {

systemservices/marketplace/src/tasks/index.ts

@@ -5,12 +5,14 @@ import { Marketplace } from "../contracts/Marketplace";
 import { createTransactionTemplate } from "../contracts/utils";
 import { ERC20 } from "../contracts/ERC20";
 
-import publishServiceVersion from "./publishServiceVersion"
+import preparePublishServiceVersion from "./preparePublishServiceVersion"
+import publishPublishServiceVersion from "./publishPublishServiceVersion"
 import getService from "./getService"
-import createServiceOffer from "./createServiceOffer"
+import prepareCreateServiceOffer from "./prepareCreateServiceOffer"
 import listServices from "./listServices"
-import purchase from "./purchase"
-import sendSignedTransaction from "./sendSignedTransaction"
+import preparePurchase from "./preparePurchase"
+import publishPurchase from "./publishPurchase"
+import publishCreateServiceOffer from "./publishCreateServiceOffer"
 import isAuthorized from "./isAuthorized"
 
 export default async (
@@ -26,10 +28,12 @@ export default async (
   mesg.listenTask({
     listServices: listServices(marketplace),
     getService: getService(marketplace),
-    publishServiceVersion: publishServiceVersion(marketplace, createTransaction),
-    createServiceOffer: createServiceOffer(marketplace, createTransaction),
-    purchase: purchase(marketplace, token, createTransaction),
-    sendSignedTransaction: sendSignedTransaction(web3),
+    preparePublishServiceVersion: preparePublishServiceVersion(marketplace, createTransaction),
+    publishPublishServiceVersion: publishPublishServiceVersion(web3, marketplace),
+    prepareCreateServiceOffer: prepareCreateServiceOffer(marketplace, createTransaction),
+    preparePurchase: preparePurchase(marketplace, token, createTransaction),
+    publishPurchase: publishPurchase(web3, marketplace),
+    publishCreateServiceOffer: publishCreateServiceOffer(web3, marketplace),
     isAuthorized: isAuthorized(marketplace),
   })
   .on('error', error => console.error('catch listenTask', error))

systemservices/marketplace/src/tasks/isAuthorized.ts

@@ -51,9 +51,6 @@ export default (
 
     // get version's manifest data
     const version = await getServiceVersion(contract, versionHash)
-    if (version === undefined) {
-      throw new Error('service with versionHash ' + versionHash + ' does not exist')
-    }
     if (version.manifestData === null) {
       throw new Error('could not download manifest of version with hash ' + versionHash)
     }

systemservices/marketplace/src/tasks/createServiceOffer.ts → systemservices/marketplace/src/tasks/prepareCreateServiceOffer.ts

@@ -15,7 +15,7 @@ export default (
     return outputs.success(await createTransaction(marketplace, inputs, transactionData))
   }
   catch (error) {
-    console.error('error in createServiceOffer', error)
+    console.error('error in prepareCreateServiceOffer', error)
     return outputs.error({ message: error.toString() })
   }
 }

systemservices/marketplace/src/tasks/publishServiceVersion.ts → systemservices/marketplace/src/tasks/preparePublishServiceVersion.ts

@@ -20,7 +20,7 @@ export default (
     return outputs.success(await createTransaction(marketplace, inputs, transactionData))
   }
   catch (error) {
-    console.error('error in publishServiceVersion', error)
+    console.error('error in preparePublishServiceVersion', error)
     return outputs.error({ message: error.toString() })
   }
 }