oceanprotocol/squid-js
1
0
Fork 0
mirror of https://github.com/oceanprotocol-archive/squid-js.git synced 2024-02-02 15:31:51 +01:00
Code Releases Activity

Merge remote-tracking branch 'remotes/origin/develop' into deploy/es-cjs-umd-min-builds

Browse Source
This commit is contained in:
diminator 2018-11-23 12:57:07 +01:00
commit faf974d03b
17 changed files with 737 additions and 415 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.bumpversion.cfg
View File

@ -1,5 +1,5 @@
[bumpversion]
current_version = 0.1.20
current_version = 0.1.24
[bumpversion:file:package.json]

749
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

6
package.json
View File

@ -1,6 +1,6 @@
{
"name": "@oceanprotocol/squid",
"version": "0.1.20",
"version": "0.1.24",
"description": "JavaScript client library for Ocean Protocol",
"main": "dist/squid.js",
"module": "dist/esm/squid.js",
@ -57,7 +57,7 @@
},
"homepage": "https://github.com/oceanprotocol/squid-js#readme",
"dependencies": {
"@oceanprotocol/keeper-contracts": "0.3.22",
"@oceanprotocol/keeper-contracts": "0.3.25",
"@oceanprotocol/secret-store-client": "0.0.12",
"bignumber.js": "^8.0.1",
"eth-crypto": "^1.2.7",
@ -73,7 +73,7 @@
"devDependencies": {
"@types/chai": "^4.1.7",
"@types/mocha": "^5.2.5",
"@types/node": "^10.12.7",
"@types/node": "^10.12.10",
"chai": "^4.2.0",
"mocha": "^5.2.0",
"nyc": "^13.1.0",

10
src/aquarius/Aquarius.ts
View File

@ -5,6 +5,8 @@ import Logger from "../utils/Logger"
import WebServiceConnectorProvider from "../utils/WebServiceConnectorProvider"
import SearchQuery from "./query/SearchQuery"
const apiPath = "/api/v1/aquarius/assets/ddo"
export default class Aquarius {
private url: string
@ -40,7 +42,7 @@ export default class Aquarius {
public async queryMetadata(query: SearchQuery): Promise<DDO[]> {
const result: DDO[] = await WebServiceConnectorProvider.getConnector()
.post(this.url + "/api/v1/aquarius/assets/ddo/query", JSON.stringify(query))
.post(`${this.url}${apiPath}/query`, JSON.stringify(query))
.then((response: any) => {
if (response.ok) {
return response.json() as DDO[]
@ -63,7 +65,7 @@ export default class Aquarius {
public async queryMetadataByText(query: SearchQuery): Promise<DDO[]> {
const fullUrl = new URL(this.url + "/api/v1/aquarius/assets/ddo/query")
const fullUrl = new URL(`${this.url}${apiPath}/query`)
fullUrl.searchParams.append("text", query.text)
fullUrl.searchParams.append("sort", decodeURIComponent(JSON.stringify(query.sort)))
fullUrl.searchParams.append("offset", query.offset.toString())
@ -91,7 +93,7 @@ export default class Aquarius {
}
public async storeDDO(ddo: DDO): Promise<DDO> {
const fullUrl = this.url + `/api/v1/aquarius/assets/ddo`
const fullUrl = `${this.url}${apiPath}`
const result: DDO = await WebServiceConnectorProvider.getConnector()
.post(fullUrl, DDO.serialize(ddo))
.then((response: any) => {
@ -113,7 +115,7 @@ export default class Aquarius {
}
public async retrieveDDO(did: string): Promise<DDO> {
const fullUrl = this.url + `/api/v1/aquarius/assets/ddo/${did}`
const fullUrl = `${this.url}${apiPath}/${did}`
const result = await WebServiceConnectorProvider.getConnector()
.get(fullUrl)
.then((response: any) => {

8
src/ddo/DDO.ts
View File

@ -38,9 +38,7 @@ export default class DDO {
throw new Error("serviceDefinitionId not set")
}
const service: Service = this.service.find((s) => {
return s.serviceDefinitionId === serviceDefinitionId
})
const service: Service = this.service.find((s) => s.serviceDefinitionId === serviceDefinitionId)
return service
}
@ -51,9 +49,7 @@ export default class DDO {
throw new Error("serviceType not set")
}
const service: Service = this.service.find((s) => {
return s.type === serviceType
})
const service: Service = this.service.find((s) => s.type === serviceType)
return service
}

9
src/keeper/contracts/ContractBase.ts
View File

@ -60,16 +60,18 @@ export default abstract class ContractBase {
if (!this.contract.methods[name]) {
throw new Error(`Method "${name}" is not part of contract "${this.contractName}"`)
}
// Logger.log(name, args)
const method = this.contract.methods[name]
try {
const tx = method(...args)
const estimatedGas = await tx.estimateGas(args, {
const methodInstance = method(...args)
const estimatedGas = await methodInstance.estimateGas(args, {
from,
})
return tx.send({
const tx = methodInstance.send({
from,
gas: estimatedGas,
})
return tx
} catch (err) {
const mappedArgs = this.searchMethod(name).inputs.map((input, i) => {
return {
@ -87,6 +89,7 @@ export default abstract class ContractBase {
if (!this.contract.methods[name]) {
throw new Error(`Method ${name} is not part of contract ${this.contractName}`)
}
// Logger.log(name)
try {
const method = this.contract.methods[name](...args)
return method.call(from ? {from} : null)

14
src/keeper/contracts/ServiceAgreement.ts
View File

@ -10,14 +10,18 @@ export default class ServiceAgreement extends ContractBase {
return serviceAgreement
}
public async setupAgreementTemplate(templateId: string, methodReflections: MethodReflection[],
dependencyMatrix: number[], name: any, fulfilmentOperator: number,
ownerAddress: string)
: Promise<Receipt> {
public async setupAgreementTemplate(templateId: string,
methodReflections: MethodReflection[],
dependencyMatrix: number[],
name: any,
fulfillmentIndices: number[],
fulfillmentOperator: number,
ownerAddress: string): Promise<Receipt> {
return this.send("setupAgreementTemplate", ownerAddress, [
templateId, methodReflections.map((r) => r.address),
methodReflections.map((r) => r.signature), dependencyMatrix, name, [0], fulfilmentOperator,
methodReflections.map((r) => r.signature), dependencyMatrix, name, fulfillmentIndices,
fulfillmentOperator,
])
}

10
src/ocean/Ocean.ts
View File

@ -13,7 +13,6 @@ import Service from "../ddo/Service"
import Keeper from "../keeper/Keeper"
import Web3Provider from "../keeper/Web3Provider"
import Config from "../models/Config"
import InputType from "../models/InputType"
import ValueType from "../models/ValueType"
import SecretStoreProvider from "../secretstore/SecretStoreProvider"
import Logger from "../utils/Logger"
@ -107,11 +106,11 @@ export default class Ocean {
return null
}
const parameters: Parameter[] = condition.methodReflection.inputs.map((input: InputType) => {
const parameters: Parameter[] = condition.parameters.map((parameter: Parameter) => {
return {
name: input.name,
type: input.type,
value: mapParameterValueToName(input.name),
name: parameter.name,
type: parameter.type,
value: mapParameterValueToName(parameter.name),
} as Parameter
})
@ -131,6 +130,7 @@ export default class Ocean {
isTerminalCondition: condition.isTerminalCondition,
} as DDOCondition
})
const serviceEndpoint = aquarius.getServiceEndpoint(did)
// create ddo itself

2
src/ocean/ServiceAgreements/Condition.ts
View File

@ -1,4 +1,5 @@
import MethodReflection from "../../models/MethodReflection"
import Parameter from "./Parameter"
export default class Condition {
public methodReflection: MethodReflection
@ -7,4 +8,5 @@ export default class Condition {
public dependencyTimeoutFlags: number[]
public isTerminalCondition: boolean
public timeout: number
public parameters: Parameter[]
}

3
src/ocean/ServiceAgreements/Method.ts
View File

@ -1,8 +1,11 @@
import Parameter from "./Parameter"
export default class Method {
public name: string
public contractName: string
public methodName: string
public timeout: number
public parameters: Parameter[]
public dependencies: string[]
public dependencyTimeoutFlags: number[]
public isTerminalCondition: boolean

4
src/ocean/ServiceAgreements/Parameter.ts Normal file
View File

@ -0,0 +1,4 @@
export default class Parameter {
public name: string
public type: string
}

80
src/ocean/ServiceAgreements/ServiceAgreement.ts
View File

@ -19,18 +19,12 @@ export default class ServiceAgreement extends OceanBase {
// Logger.log("signing SA", serviceAgreementId)
const service: Service = ddo.findServiceById(serviceDefinitionId)
const values: ValuePair[] = ServiceAgreement.getValuesFromService(service, serviceAgreementId)
const valueHashes = ServiceAgreement.createValueHashes(values)
const values: ValuePair[][] = ServiceAgreement.getValuesFromService(service, serviceAgreementId)
const valueHashes: string[] = ServiceAgreement.createValueHashes(values)
const timeoutValues: number[] = ServiceAgreement.getTimeoutValuesFromService(service)
const serviceAgreementHashSignature = await ServiceAgreement
.createSAHashSignature(
service,
serviceAgreementId,
values,
valueHashes,
timeoutValues,
consumer)
const serviceAgreementHashSignature = await ServiceAgreement.createSAHashSignature(service, serviceAgreementId,
valueHashes, timeoutValues, consumer)
return serviceAgreementHashSignature
}
@ -46,8 +40,8 @@ export default class ServiceAgreement extends OceanBase {
// Logger.log("executing SA", serviceAgreementId)
const service: Service = ddo.findServiceById(serviceDefinitionId)
const values: ValuePair[] = ServiceAgreement.getValuesFromService(service, serviceAgreementId)
const valueHashes = ServiceAgreement.createValueHashes(values)
const values: ValuePair[][] = ServiceAgreement.getValuesFromService(service, serviceAgreementId)
const valueHashes: string[] = ServiceAgreement.createValueHashes(values)
const timeoutValues: number[] = ServiceAgreement.getTimeoutValuesFromService(service)
// todo get consumer from ddo
@ -60,11 +54,9 @@ export default class ServiceAgreement extends OceanBase {
private static async createSAHashSignature(service: Service,
serviceAgreementId: string,
values: ValuePair[],
valueHashes: string[],
timeoutValues: number[],
consumer: Account):
Promise<string> {
consumer: Account): Promise<string> {
if (!service.templateId) {
throw new Error("TemplateId not found in ddo.")
@ -74,8 +66,11 @@ export default class ServiceAgreement extends OceanBase {
return condition.conditionKey
})
const serviceAgreementHash = ServiceAgreement
.hashServiceAgreement(
if (conditionKeys.length !== valueHashes.length) {
throw new Error("Hashing SA failed!")
}
const serviceAgreementHash = ServiceAgreement.hashServiceAgreement(
service.templateId,
serviceAgreementId,
conditionKeys,
@ -130,18 +125,31 @@ export default class ServiceAgreement extends OceanBase {
)
}
private static createValueHashes(valuePairs: ValuePair[]): any[] {
return valuePairs.map((valuePair) => {
return ServiceAgreement.hashSingleValue(valuePair)
private static createValueHashes(parameterValuePairs: ValuePair[][]): string[] {
const hashes: string[] = []
parameterValuePairs.map((valuePairs: ValuePair[]) => {
hashes.push(ServiceAgreement.hashValuePairArray(valuePairs))
})
return hashes
}
private static hashSingleValue(data: ValuePair): string {
private static hashValuePairArray(valuePairs: ValuePair[]): string {
let hash: string
try {
return Web3Provider.getWeb3().utils.soliditySha3(data).toString("hex")
hash = Web3Provider.getWeb3().utils.soliditySha3(...valuePairs).toString("hex")
} catch (err) {
Logger.error(`Hashing of ${JSON.stringify(data, null, 2)} failed.`)
Logger.error(`Hashing of ${JSON.stringify(valuePairs, null, 2)} failed.`)
throw err
}
if (!hash) {
throw new Error("hashValuePairArray failed to create hash.")
}
return hash
}
private static hashServiceAgreement(serviceAgreementTemplateId: string,
@ -168,20 +176,22 @@ export default class ServiceAgreement extends OceanBase {
return timeoutValues
}
private static getValuesFromService(service: Service, serviceAgreementId: string): ValuePair[] {
private static getValuesFromService(service: Service, serviceAgreementId: string): ValuePair[][] {
const values: ValuePair[] = []
const values: ValuePair[][] = []
service.conditions.forEach((condition) => {
service.conditions.forEach((condition, i) => {
const contionValues: ValuePair[] = []
condition.parameters.forEach((parameter) => {
values.push({
contionValues.push({
type: parameter.type,
value: parameter.name === "serviceId" ? "0x" + serviceAgreementId : parameter.value,
} as ValuePair)
})
})
// Logger.log("Values", JSON.stringify(values, null, 2))
values[i] = contionValues
})
return values
}
@ -195,14 +205,16 @@ export default class ServiceAgreement extends OceanBase {
super(serviceAgreementId)
}
public async lockPayment(assetId: string, price: number, consumer: Account): Promise<boolean> {
const {paymentConditions} = await Keeper.getInstance()
public async buyAsset(assetId: string, price: number, consumer: Account): Promise<boolean> {
const {paymentConditions, token} = await Keeper.getInstance()
const lockPaymentRceipt =
await token.approve(paymentConditions.getAddress(), price, consumer.getId())
const lockPaymentReceipt =
await paymentConditions.lockPayment(this.getId(), assetId, price,
consumer.getId())
return lockPaymentRceipt.status
return lockPaymentReceipt.status
}
public async grantAccess(assetId: string, documentId: string): Promise<boolean> {
@ -212,7 +224,7 @@ export default class ServiceAgreement extends OceanBase {
await accessConditions.grantAccess(this.getId(), assetId, documentId,
this.publisher.getId())
return grantAccessReceipt.status
return !!grantAccessReceipt.events.AccessGranted
}
public async getStatus() {

52
src/ocean/ServiceAgreements/ServiceAgreementTemplate.ts
View File

@ -12,8 +12,8 @@ import TemplateBase from "./Templates/TemplateBase"
export default class ServiceAgreementTemplate extends OceanBase {
private static generateConditionsKey(serviceAgreementTemplateId: string, methodReflection: MethodReflection)
: string {
private static generateConditionsKey(serviceAgreementTemplateId: string,
methodReflection: MethodReflection): string {
const values = [
{type: "bytes32", value: serviceAgreementTemplateId} as ValuePair,
{type: "address", value: methodReflection.address} as ValuePair,
@ -34,9 +34,11 @@ export default class ServiceAgreementTemplate extends OceanBase {
return this.compressDependencies(method.dependencies, method.dependencyTimeoutFlags)
}))
const {serviceAgreement} = await Keeper.getInstance()
const fulfillmentIndices: number[] = this.template.Methods
.map((method: Method, i: number) => method.isTerminalCondition ? i : null)
.filter((index: number) => index !== null)
const methodReflections = await this.getMethodReflections()
const {serviceAgreement} = await Keeper.getInstance()
const owner = await this.getOwner()
@ -54,10 +56,12 @@ export default class ServiceAgreementTemplate extends OceanBase {
const receipt = await serviceAgreement
.setupAgreementTemplate(
this.template.id,
methodReflections,
await this.getMethodReflections(),
dependencyMatrix,
Web3Provider.getWeb3().utils.fromAscii(this.template.templateName),
this.template.fulfilmentOperator, templateOwnerAddress)
fulfillmentIndices,
this.template.fulfillmentOperator,
templateOwnerAddress)
const {serviceTemplateId, provider} = receipt.events.SetupAgreementTemplate.returnValues
@ -100,6 +104,7 @@ export default class ServiceAgreementTemplate extends OceanBase {
return {
methodReflection,
timeout: method.timeout,
parameters: method.parameters,
dependencies: method.dependencies,
dependencyTimeoutFlags: method.dependencyTimeoutFlags,
isTerminalCondition: method.isTerminalCondition,
@ -117,23 +122,32 @@ export default class ServiceAgreementTemplate extends OceanBase {
throw new Error("Deps and timeouts need the same length")
}
// map name to index
const mappedDependencies: number[] = dependencies.map((dep: string) => {
return this.template.Methods.findIndex((m) => m.name === dep)
const mappedDependencies: number[] = []
const mappedDependencyTimeoutFlags: number[] = []
this.template.Methods.forEach((m, i) => {
const di = dependencies.findIndex((d) => d === m.name)
mappedDependencies.push(di > -1 ? 1 : 0)
mappedDependencyTimeoutFlags.push((di > -1 && dependencyTimeoutFlags[di]) ? 1 : 0)
})
let compressedDependencyValue = 0
const numBits = 2 // 1st for dependency, 2nd for timeout flag
for (let i = 0; i < mappedDependencies.length; i++) {
const dependencyIndex = mappedDependencies[i]
const timeout = dependencyTimeoutFlags[i]
const offset = i * numBits
// tslint:disable-next-line
compressedDependencyValue |= dependencyIndex * 2 ** (offset + 0) // the dependency bit
// tslint:disable-next-line
compressedDependencyValue |= timeout * 2 ** (offset + 1) // the timeout bit
if (mappedDependencies.length !== mappedDependencyTimeoutFlags.length) {
throw new Error("Deps and timeouts need the same length")
}
// Logger.log(dependencies, mappedDependencies, dependencyTimeoutFlags, mappedDependencyTimeoutFlags)
let compressedDependencyValue: number = 0
const numBits: number = 2 // 1st for dependency, 2nd for timeout flag
mappedDependencies.forEach((d: number, i: number) => {
const t: number = mappedDependencyTimeoutFlags[i]
const offset: number = i * numBits
// tslint:disable-next-line
compressedDependencyValue |= d * 2 ** (offset + 0) // the dependency bit
// tslint:disable-next-line
compressedDependencyValue |= t * 2 ** (offset + 1) // the timeout bit
})
return compressedDependencyValue
}

40
src/ocean/ServiceAgreements/Templates/Access.ts
View File

@ -11,6 +11,16 @@ export default class Access extends TemplateBase {
contractName: "PaymentConditions",
methodName: "lockPayment",
timeout: 0,
parameters: [
{
name: "assetId",
type: "bytes32",
},
{
name: "price",
type: "uint256",
},
],
dependencies: [],
dependencyTimeoutFlags: [],
isTerminalCondition: false,
@ -20,6 +30,16 @@ export default class Access extends TemplateBase {
contractName: "AccessConditions",
methodName: "grantAccess",
timeout: 10,
parameters: [
{
name: "assetId",
type: "bytes32",
},
{
name: "documentKeyId",
type: "bytes32",
},
],
dependencies: ["lockPayment"],
dependencyTimeoutFlags: [0],
isTerminalCondition: false,
@ -29,6 +49,16 @@ export default class Access extends TemplateBase {
contractName: "PaymentConditions",
methodName: "releasePayment",
timeout: 10,
parameters: [
{
name: "assetId",
type: "bytes32",
},
{
name: "price",
type: "uint256",
},
],
dependencies: ["grantAccess"],
dependencyTimeoutFlags: [0],
isTerminalCondition: true,
@ -38,6 +68,16 @@ export default class Access extends TemplateBase {
contractName: "PaymentConditions",
methodName: "refundPayment",
timeout: 10,
parameters: [
{
name: "assetId",
type: "bytes32",
},
{
name: "price",
type: "uint256",
},
],
dependencies: ["lockPayment", "grantAccess"],
dependencyTimeoutFlags: [0, 1],
isTerminalCondition: true,

2
src/ocean/ServiceAgreements/Templates/TemplateBase.ts
View File

@ -3,6 +3,6 @@ import Method from "../Method"
export default abstract class TemplateBase {
public Methods: Method[]
public templateName: string
public fulfilmentOperator: number = 0
public fulfillmentOperator: number = 1
public id: string = "0x00000000000000000000000000000000000000000000000000000000000000"
}

2
test/keeper/TestContractHandler.ts
View File

@ -17,7 +17,9 @@ export default class TestContractHandler extends ContractHandler {
await TestContractHandler.deployContracts(deployerAddress)
// register templates
Logger.log(`Registering Access Template from ${deployerAddress}`)
await new ServiceAgreementTemplate(new Access()).register(deployerAddress)
Logger.log(`Registering FitchainCompute Template from ${deployerAddress}`)
await new ServiceAgreementTemplate(new FitchainCompute()).register(deployerAddress)
}

75
test/ocean/ServiceAgreement.test.ts
View File

@ -7,7 +7,6 @@ import EventHandlers from "../../src/ddo/EventHandlers"
import MetaData from "../../src/ddo/MetaData"
import Parameter from "../../src/ddo/Parameter"
import Service from "../../src/ddo/Service"
import InputType from "../../src/models/InputType"
import Account from "../../src/ocean/Account"
import IdGenerator from "../../src/ocean/IdGenerator"
import Ocean from "../../src/ocean/Ocean"
@ -49,7 +48,8 @@ describe("ServiceAgreement", () => {
const conditions: Condition[] = await serviceAgreementTemplate.getConditions()
// create ddo conditions out of the keys
const ddoConditions: DDOCondition[] = conditions.map((condition, index): DDOCondition => {
const ddoConditions: DDOCondition[] = conditions
.map((condition: Condition, index): DDOCondition => {
const events: Event[] = [
{
@ -73,17 +73,19 @@ describe("ServiceAgreement", () => {
case "assetId":
return "0x" + assetId
case "documentKeyId":
return "0x1234"
return "0x" + assetId
}
return null
}
const parameters: Parameter[] = condition.methodReflection.inputs.map((input: InputType) => {
const parameters: Parameter[] = condition.parameters
.map((parameter: Parameter) => {
return {
name: input.name,
type: input.type,
value: mapParameterValueToName(input.name),
name: parameter.name,
type: parameter.type,
value: mapParameterValueToName(parameter.name),
} as Parameter
})
@ -117,8 +119,7 @@ describe("ServiceAgreement", () => {
describe("#signServiceAgreement()", () => {
it("should sign an service agreement", async () => {
const id: string = IdGenerator.generateId()
const did: string = `did:op:${id}`
const did: string = `did:op:${assetId}`
const ddo = new DDO({id: did, service: [accessService]})
const serviceAgreementId: string = IdGenerator.generateId()
@ -137,8 +138,7 @@ describe("ServiceAgreement", () => {
describe("#executeServiceAgreement()", () => {
it("should execute an service agreement", async () => {
const id: string = IdGenerator.generateId()
const did: string = `did:op:${id}`
const did: string = `did:op:${assetId}`
const ddo = new DDO({id: did, service: [accessService]})
const serviceAgreementId: string = IdGenerator.generateId()
@ -162,8 +162,7 @@ describe("ServiceAgreement", () => {
describe("#getStatus()", () => {
it("should get the status of a newly created service agreement", async () => {
const id: string = IdGenerator.generateId()
const did: string = `did:op:${id}`
const did: string = `did:op:${assetId}`
const ddo = new DDO({id: did, service: [accessService]})
const serviceAgreementId: string = IdGenerator.generateId()
@ -184,16 +183,16 @@ describe("ServiceAgreement", () => {
})
})
describe("#lockPayment()", () => {
xit("should lock the payment in that service agreement", async () => {
describe("#buyAsset()", () => {
it("should lock the payment in that service agreement", async () => {
const id: string = IdGenerator.generateId()
const did: string = `did:op:${id}`
const did: string = `did:op:${assetId}`
const ddo = new DDO({id: did, service: [accessService, metaDataService]})
const serviceAgreementId: string = IdGenerator.generateId()
// @ts-ignore
WebServiceConnectorProvider.setConnector(new WebServiceConnectorMock(ddo))
const serviceAgreementSignature: string =
await ServiceAgreement.signServiceAgreement(assetId, ddo, accessService.serviceDefinitionId,
serviceAgreementId, consumerAccount)
@ -204,17 +203,19 @@ describe("ServiceAgreement", () => {
serviceAgreementId, serviceAgreementSignature, consumerAccount, publisherAccount)
assert(serviceAgreement)
const paid: boolean = await serviceAgreement.lockPayment(assetId, metaDataService.metadata.base.price,
// get funds
await consumerAccount.requestTokens(metaDataService.metadata.base.price)
const paid: boolean = await serviceAgreement.buyAsset(assetId, metaDataService.metadata.base.price,
consumerAccount)
assert(paid)
})
})
describe("#grantAccess()", () => {
xit("should grant access in that service agreement", async () => {
it("should grant access in that service agreement", async () => {
const id: string = IdGenerator.generateId()
const did: string = `did:op:${id}`
const did: string = `did:op:${assetId}`
const ddo = new DDO({id: did, service: [accessService]})
const serviceAgreementId: string = IdGenerator.generateId()
@ -230,11 +231,39 @@ describe("ServiceAgreement", () => {
serviceAgreementId, serviceAgreementSignature, consumerAccount, publisherAccount)
assert(serviceAgreement)
const paid: boolean = await serviceAgreement.lockPayment(assetId, 10, consumerAccount)
// get funds
await consumerAccount.requestTokens(metaDataService.metadata.base.price)
const paid: boolean = await serviceAgreement.buyAsset(assetId, metaDataService.metadata.base.price,
consumerAccount)
assert(paid)
const accessGranted: boolean = await serviceAgreement.grantAccess(assetId, IdGenerator.generateId())
// todo: use document id
const accessGranted: boolean = await serviceAgreement.grantAccess(assetId, assetId)
assert(accessGranted)
})
it("should fail to grant grant access if there is no payment", async () => {
const did: string = `did:op:${assetId}`
const ddo = new DDO({id: did, service: [accessService]})
const serviceAgreementId: string = IdGenerator.generateId()
// @ts-ignore
WebServiceConnectorProvider.setConnector(new WebServiceConnectorMock(ddo))
const serviceAgreementSignature: string =
await ServiceAgreement.signServiceAgreement(assetId, ddo, accessService.serviceDefinitionId,
serviceAgreementId, consumerAccount)
assert(serviceAgreementSignature)
const serviceAgreement: ServiceAgreement =
await ServiceAgreement.executeServiceAgreement(assetId, ddo, accessService.serviceDefinitionId,
serviceAgreementId, serviceAgreementSignature, consumerAccount, publisherAccount)
assert(serviceAgreement)
// todo: use document id
const accessGranted: boolean = await serviceAgreement.grantAccess(assetId, assetId)
assert(!accessGranted)
})
})
})