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

migrated to typescript

Browse Source
This commit is contained in:
Sebastian Gerske 2018-09-25 08:30:54 +02:00
parent 2e18f8e411
commit 20c10a8ef5
21 changed files with 314 additions and 4643 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4251
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

27
package.json
View File

@ -5,8 +5,8 @@
"main": "dist/squid.js",
"scripts": {
"test": "eslint ./src",
"start": "babel ./src/ --watch --out-dir ./dist/",
"build": "babel ./src/ --out-dir ./dist/",
"start": "tsc -w",
"build": "tsc",
"release": "./node_modules/release-it/bin/release-it.js --src.tagName='v%s' --github.release --npm.publish --non-interactive",
"release-minor": "./node_modules/release-it/bin/release-it.js minor --src.tagName='v%s' --github.release --npm.publish --non-interactive",
"release-major": "./node_modules/release-it/bin/release-it.js major --src.tagName='v%s' --github.release --npm.publish --non-interactive",
@ -24,27 +24,16 @@
},
"homepage": "https://github.com/oceanprotocol/squid-js#readme",
"dependencies": {
"@babel/runtime": "^7.0.0",
"@oceanprotocol/keeper-contracts": "^0.2.0",
"bn.js": "^4.11.8",
"truffle-contract": "^3.0.6",
"web3": "0.20.6"
},
"devDependencies": {
"@babel/cli": "^7.0.0",
"@babel/core": "^7.0.1",
"@babel/plugin-proposal-object-rest-spread": "^7.0.0",
"@babel/plugin-transform-runtime": "^7.0.0",
"@babel/preset-env": "^7.0.0",
"eslint": "^5.5.0",
"eslint-config-oceanprotocol": "^1.2.0",
"eslint-config-standard": "^12.0.0",
"eslint-plugin-import": "^2.14.0",
"eslint-plugin-node": "^7.0.1",
"eslint-plugin-promise": "^4.0.0",
"eslint-plugin-security": "^1.4.0",
"eslint-plugin-standard": "^4.0.0"
"web3": "0.20.6",
"whatwg-fetch": "^3.0.0"
},
"engines": {
"node": ">=8 <10"
},
"devDependencies": {
"@types/web3": "^1.0.6"
}
}

39
src/deprecated/ocean-agent.js
View File

@ -1,39 +0,0 @@
/* global fetch */
import Logger from '../utils/logger'
export default class OceanAgent {
constructor(connectionUrl) {
this.assetsUrl = connectionUrl + '/assets'
Logger.warn('OceanAgent is deprecated use the Ocean object from squid instead')
}
getAssetsMetadata() {
return fetch(this.assetsUrl + '/metadata', { method: 'GET' })
.then(res => res.json())
.then(data => JSON.parse(data))
}
publishDataAsset(asset) {
return fetch(this.assetsUrl + '/metadata',
{
method: 'POST',
body: JSON.stringify(asset),
headers: { 'Content-type': 'application/json' }
})
.then(response => {
Logger.log('Success:', response)
if (response.ok) {
Logger.log('Success:', response)
return true
}
Logger.log('Failed: ', response.status, response.statusText)
return false
// throw new Error(response.statusText ? response.statusText : `publish asset failed with status ${response.status}`)
})
.catch(error => {
Logger.log(`Publish asset to ocean database could not be completed: ${error.message()}`)
return false
})
}
}

181
src/deprecated/ocean-keeper.js
View File

@ -1,181 +0,0 @@
import Web3 from 'web3'
import ContractLoader from '../keeper/contractLoader'
import Logger from '../utils/logger'
const DEFAULT_GAS = 300000
export default class OceanKeeper {
constructor(uri, network) {
const web3Provider = new Web3.providers.HttpProvider(uri)
this.web3 = new Web3(web3Provider)
this.defaultGas = DEFAULT_GAS
this.network = network || 'development'
Logger.warn('OceanKeeper is deprecated use the Ocean object from squid instead')
}
async initContracts() {
this.oceanToken = await ContractLoader.load('OceanToken', this.network, this.web3)
this.oceanMarket = await ContractLoader.load('OceanMarket', this.network, this.web3)
this.oceanAuth = await ContractLoader.load('OceanAuth', this.network, this.web3)
return {
oceanToken: this.oceanToken,
oceanMarket: this.oceanMarket,
oceanAuth: this.oceanAuth
}
}
// web3 wrappers
sign(accountAddress, message) {
return this.web3.eth.sign(accountAddress, message)
}
getMessageHash(message) {
return this.web3.sha3(`\x19Ethereum Signed Message:\n${message.length}${message}`)
}
// call functions (costs no gas)
checkAsset(assetId) {
return this.oceanMarket.checkAsset(assetId)
}
getBalance(accountAddress) {
return this.oceanToken.balanceOf.call(accountAddress)
}
getAssetPrice(assetId) {
return this.oceanMarket.getAssetPrice(assetId).then((price) => price.toNumber())
}
getOrderStatus(orderId) {
return this.oceanAuth.statusOfAccessRequest(orderId)
}
verifyOrderPayment(orderId) {
return this.oceanMarket.verifyPaymentReceived(orderId)
}
getEncryptedAccessToken(orderId, senderAddress) {
return this.oceanAuth.getEncryptedAccessToken(orderId, { from: senderAddress })
}
async getConsumerOrders(consumerAddress) {
let accessConsentEvent = this.oceanAuth.AccessConsentRequested({ _consumer: consumerAddress }, {
fromBlock: 0,
toBlock: 'latest'
})
let _resolve = null
let _reject = null
const promise = new Promise((resolve, reject) => {
_resolve = resolve
_reject = reject
})
const getEvents = () => {
accessConsentEvent.get((error, logs) => {
if (error) {
_reject(error)
throw new Error(error)
} else {
_resolve(logs)
}
})
return promise
}
const events = await getEvents().then((events) => events)
// let orders = await this.buildOrdersFromEvents(events, consumerAddress).then((result) => result)
let orders = events
.filter(obj => (obj.args._consumer === consumerAddress))
.map(async (event) => ({
...event.args,
timeout: event.args._timeout.toNumber(),
status: await this.getOrderStatus(event.args._id).then((status) => status.toNumber()),
paid: await this.verifyOrderPayment(event.args._id).then((received) => received),
key: null
}))
Logger.debug('got orders: ', orders)
return orders
}
// Transactions with gas cost
requestTokens(senderAddress, numTokens) {
return this.oceanMarket.requestTokens(numTokens, { from: senderAddress })
}
async registerDataAsset(name, description, price, publisherAddress) {
const assetId = await this.oceanMarket.generateId(name + description)
const result = await this.oceanMarket.register(
assetId,
price,
{ from: publisherAddress, gas: this.defaultGas }
)
Logger.log('registered: ', result)
return assetId
}
async sendPayment(assetId, order, publisherAddress, senderAddress) {
let assetPrice = await this.oceanMarket.getAssetPrice(assetId).then((price) => price.toNumber())
this.oceanMarket.sendPayment(order.id, publisherAddress, assetPrice, order.timeout, {
from: senderAddress,
gas: 2000000
})
}
cancelAccessRequest(orderId, senderAddress) {
return this.oceanAuth.cancelAccessRequest(orderId, { from: senderAddress })
}
orchestrateResourcePurchase(
assetId, publisherId, price, privateKey, publicKey, timeout, senderAddress,
initialRequestEventHandler, accessCommittedEventHandler, tokenPublishedEventHandler) {
const { oceanToken, oceanMarket, oceanAuth } = this
// Allow OceanMarket contract to transfer funds on the consumer's behalf
oceanToken.approve(oceanMarket.address, price, { from: senderAddress, gas: 2000000 })
// Submit the access request
oceanAuth.initiateAccessRequest(
assetId, publisherId, publicKey,
timeout, { from: senderAddress, gas: 1000000 }
)
const resourceFilter = { _resourceId: assetId, _consumer: senderAddress }
const initRequestEvent = oceanAuth.AccessConsentRequested(resourceFilter)
let order = {}
this._listenOnce(
initRequestEvent,
'AccessConsentRequested',
(result, error) => {
order = initialRequestEventHandler(result, error)
const requestIdFilter = { _id: order.id }
const accessCommittedEvent = oceanAuth.AccessRequestCommitted(requestIdFilter)
const tokenPublishedEvent = oceanAuth.EncryptedTokenPublished(requestIdFilter)
this._listenOnce(
accessCommittedEvent,
'AccessRequestCommitted',
(result, error) => {
accessCommittedEventHandler(result, order, error)
}
)
this._listenOnce(
tokenPublishedEvent,
'EncryptedTokenPublished',
(result, error) => {
tokenPublishedEventHandler(result, order, error)
}
)
})
return order
}
// Helper functions (private)
_listenOnce(event, eventName, callback) {
event.watch((error, result) => { // eslint-disable-line security/detect-non-literal-fs-filename
event.stopWatching()
if (error) {
Logger.log(`Error in keeper ${eventName} event: `, error)
}
callback(result, error)
})
}
}

25
src/keeper/auth.js
View File

@ -1,25 +0,0 @@
import ContractLoader from './contractLoader'
import KeeperBase from './keeper-base'
export default class OceanAuth extends KeeperBase {
constructor(web3Helper) {
super(web3Helper)
return (async () => {
this.contract = await ContractLoader.load('OceanAuth', this._web3Helper)
return this
})()
}
cancelAccessRequest(orderId, senderAddress) {
return this.contract.cancelAccessRequest(orderId, { from: senderAddress })
}
getOrderStatus(orderId) {
return this.contract.statusOfAccessRequest(orderId)
}
getEncryptedAccessToken(orderId, senderAddress) {
return this.contract.getEncryptedAccessToken(orderId, { from: senderAddress })
}
}

30
src/keeper/auth.ts Normal file
View File

@ -0,0 +1,30 @@
import ContractLoader from './contractLoader'
import KeeperBase from './keeper-base'
import Web3Helper from "../utils/Web3Helper";
import Config from "../utils/config";
export default class OceanAuth extends KeeperBase {
private constructor(config: Config, web3Helper: Web3Helper) {
super(config, web3Helper)
}
public static async getInstance(config: Config, web3Helper) {
const auth = new OceanAuth(config, web3Helper);
auth.contract = await ContractLoader.load('OceanAuth', auth._web3Helper)
return auth;
}
cancelAccessRequest(orderId: string, senderAddress: string) {
return this.contract.cancelAccessRequest(orderId, {from: senderAddress})
}
getOrderStatus(orderId: string) {
return this.contract.statusOfAccessRequest(orderId)
}
getEncryptedAccessToken(orderId: string, senderAddress: string) {
return this.contract.getEncryptedAccessToken(orderId, {from: senderAddress})
}
}

15
src/keeper/contractLoader.js → src/keeper/contractLoader.ts
View File

@ -1,10 +1,11 @@
import TruffleContract from 'truffle-contract'
import * as TruffleContract from 'truffle-contract'
import Logger from '../utils/logger'
import Web3Helper from '../utils/Web3Helper'
const contracts = []
const contracts: Map<string, object> = new Map<string, object>()
export default class ContractLoader {
static async _doLoad(what, web3Helper) {
static async _doLoad(what: string, web3Helper: Web3Helper): Promise<object> {
const where = (await web3Helper.getNetworkName()).toLowerCase()
Logger.log('Loading', what, 'from', where)
try {
@ -15,14 +16,14 @@ export default class ContractLoader {
const contract = TruffleContract(artifact)
Logger.log('Getting instance of', what, 'from', where, 'at', artifact.address)
contract.setProvider(web3Helper.web3.currentProvider)
contracts[what] = await contract.at(artifact.address)
return contracts[what]
contracts.set(what, await contract.at(artifact.address))
return contracts.get(what)
} catch (err) {
Logger.error('Failed to load', what, 'from', where)
}
}
static async load(what, where, provider) {
return contracts[what] || ContractLoader._doLoad(what, where, provider)
static async load(what: string, web3Helper: Web3Helper) {
return contracts.get(what) || await ContractLoader._doLoad(what, web3Helper)
}
}

6
src/keeper/keeper-base.js
View File

@ -1,6 +0,0 @@
export default class KeeperBase {
constructor(web3Helper) {
this._web3Helper = web3Helper
this.contract = null
}
}

14
src/keeper/keeper-base.ts Normal file
View File

@ -0,0 +1,14 @@
import Web3Helper from '../utils/Web3Helper'
import Config from "../utils/config";
export default class KeeperBase {
protected _config: Config
protected _web3Helper: Web3Helper;
public contract: any = null;
constructor(config: Config, web3Helper: Web3Helper) {
this._config = config;
this._web3Helper = web3Helper
}
}

53
src/keeper/market.js
View File

@ -1,53 +0,0 @@
import ContractLoader from './contractLoader'
import KeeperBase from './keeper-base'
import Logger from '../utils/logger'
export default class OceanMarket extends KeeperBase {
constructor(web3Helper) {
super(web3Helper)
return (async () => {
this.contract = await ContractLoader.load('OceanMarket', this._web3Helper)
return this
})()
}
// call functions (costs no gas)
checkAsset(assetId) {
return this.contract.checkAsset(assetId)
}
verifyOrderPayment(orderId) {
return this.contract.verifyPaymentReceived(orderId)
}
getAssetPrice(assetId) {
return this.contract.getAssetPrice(assetId)
.then((price) => price.toNumber())
}
// Transactions with gas cost
requestTokens(amount, address) {
return this.contract.requestTokens(amount, { from: address })
}
async registerAsset(name, description, price, publisherAddress) {
const assetId = await this.contract.generateId(name + description)
const result = await this.contract.register(
assetId,
price,
{ from: publisherAddress, gas: this.defaultGas }
)
Logger.log('registered: ', result)
return assetId
}
async payAsset(assetId, order, publisherAddress, senderAddress) {
let assetPrice = await this.contract.getAssetPrice(assetId).then((price) => price.toNumber())
this.contract.sendPayment(order.id, publisherAddress, assetPrice, order.timeout, {
from: senderAddress,
gas: 2000000
})
}
}

61
src/keeper/market.ts Normal file
View File

@ -0,0 +1,61 @@
import ContractLoader from './contractLoader'
import KeeperBase from './keeper-base'
import Logger from '../utils/logger'
import Web3Helper from "../utils/Web3Helper";
import BigNumber from "bignumber.js";
import Config from "../utils/config";
export default class OceanMarket extends KeeperBase {
private constructor(config: Config, web3Helper: Web3Helper) {
super(config, web3Helper)
}
public static async getInstance(config: Config, web3Helper: Web3Helper) {
const market = new OceanMarket(config, web3Helper);
market.contract = await ContractLoader.load('OceanMarket', market._web3Helper)
return market;
}
// call functions (costs no gas)
checkAsset(assetId: string) {
return this.contract.checkAsset(assetId)
}
verifyOrderPayment(orderId: string): boolean {
return this.contract.verifyPaymentReceived(orderId)
}
getAssetPrice(assetId: string) {
return this.contract.getAssetPrice(assetId)
.then((price: BigNumber) => price.toNumber())
}
// Transactions with gas cost
requestTokens(amount: number, address: string) {
return this.contract.requestTokens(amount, {from: address})
}
async registerAsset(name: string, description: string, price: number, publisherAddress: string) {
const assetId = await this.contract.generateId(name + description)
const result = await this.contract.register(
assetId,
price, {
from: publisherAddress, gas:
this._config.defaultGas
}
)
Logger.log('registered: ', result)
return assetId
}
async payAsset(assetId: string, order: any, publisherAddress: string, senderAddress: string) {
let assetPrice = await this.contract.getAssetPrice(assetId)
.then((price: BigNumber) => price.toNumber())
this.contract.sendPayment(order.id, publisherAddress, assetPrice, order.timeout, {
from: senderAddress,
gas: 2000000
})
}
}

30
src/keeper/token.js
View File

@ -1,30 +0,0 @@
import ContractLoader from './contractLoader'
import KeeperBase from './keeper-base'
import Logger from '../utils/logger'
export default class OceanToken extends KeeperBase {
constructor(web3Helper) {
super(web3Helper)
return (async () => {
this.contract = await ContractLoader.load('OceanToken', this._web3Helper)
return this
})()
}
getTokenBalance(accountAddress) {
return this.contract.balanceOf.call(accountAddress)
}
async getEthBalance(account) {
return new Promise((resolve, reject) => {
Logger.log('getting balance for', account)
this._web3Helper.web3.eth.getBalance(account, 'latest', (err, balance) => {
if (err) return reject(err)
Logger.log('balance', balance)
resolve(balance)
})
})
}
}

34
src/keeper/token.ts Normal file
View File

@ -0,0 +1,34 @@
import ContractLoader from './contractLoader'
import KeeperBase from './keeper-base'
import Logger from '../utils/logger'
import Web3Helper from "../utils/Web3Helper"
import Config from "../utils/config";
export default class OceanToken extends KeeperBase {
private constructor(config: Config, web3Helper: Web3Helper) {
super(config, web3Helper)
}
public static async getInstance(config: Config, web3Helper: Web3Helper) {
const token = new OceanToken(config, web3Helper)
token.contract = await ContractLoader.load('OceanToken', token._web3Helper)
return token;
}
getTokenBalance(accountAddress: string) {
return this.contract.balanceOf.call(accountAddress)
}
async getEthBalance(account: string): Promise<number> {
return new Promise<number>((resolve, reject) => {
Logger.log('getting balance for', account)
this._web3Helper.web3.eth.getBalance(account, 'latest', (err: any, balance: number) => {
if (err) return reject(err)
Logger.log('balance', balance)
resolve(balance)
})
})
}
}

19
src/metadata.js → src/metadata.ts
View File

@ -1,8 +1,15 @@
/* global fetch */
import Logger from './utils/logger'
import Config from "./utils/config";
declare var fetch
export default class MetaData {
constructor(providerUri) {
private assetsUrl: string;
constructor(config: Config) {
const providerUri = config.providerUri || null
this.assetsUrl = providerUri + '/assets'
}
@ -12,14 +19,14 @@ export default class MetaData {
.then(data => JSON.parse(data))
}
publishDataAsset(asset) {
publishDataAsset(asset: object) {
return fetch(this.assetsUrl + '/metadata',
{
method: 'POST',
body: JSON.stringify(asset),
headers: { 'Content-type': 'application/json' }
})
.then(response => {
.then((response: any) => {
Logger.log('Success:', response)
if (response.ok) {
Logger.log('Success:', response)
@ -29,8 +36,8 @@ export default class MetaData {
return false
// throw new Error(response.statusText ? response.statusText : `publish asset failed with status ${response.status}`)
})
.catch(error => {
Logger.log(`Publish asset to ocean database could not be completed: ${error.message()}`)
.catch((error: Error) => {
Logger.log(`Publish asset to ocean database could not be completed: ${error.message}`)
return false
})
}

92
src/ocean.js → src/ocean.ts
View File

@ -1,36 +1,43 @@
import Web3 from 'web3'
import OceanMarket from './keeper/market'
import OceanAuth from './keeper/auth'
import OceanToken from './keeper/token'
import Logger from './utils/logger'
import Web3Helper from './utils/Web3Helper'
import MetaData from './metadata'
const DEFAULT_GAS = 300000
import BigNumber = require("bn.js")
import Config from "./utils/config";
export default class Ocean {
constructor(config) {
const web3Provider = config.web3Provider || new Web3.providers.HttpProvider(config.nodeUri)
this._web3 = new Web3(web3Provider)
this._defaultGas = config.gas || DEFAULT_GAS
this._providerUri = config.providerUri || null
this.helper = new Web3Helper(this._web3)
this.metadata = new MetaData(this._providerUri)
private _config: Config;
return (async () => {
this._network = config.network || (await this.helper.getNetworkName()).toLowerCase() || 'development'
public token: OceanToken;
public market: OceanMarket;
public auth: OceanAuth;
public helper: Web3Helper;
public metadata: MetaData;
this.market = await new OceanMarket(this.helper)
this.auth = await new OceanAuth(this.helper)
this.token = await new OceanToken(this.helper)
private constructor(config: Config) {
return this
})()
this._config = config;
this.helper = new Web3Helper(config)
this.metadata = new MetaData(config)
}
public static async getInstance(config) {
const ocean = new Ocean(config);
ocean.market = await OceanMarket.getInstance(config, ocean.helper)
ocean.auth = await OceanAuth.getInstance(config, ocean.helper)
ocean.token = await OceanToken.getInstance(config, ocean.helper)
return ocean;
}
async getAccounts() {
return Promise.all((await this.helper.getAccounts()).map(async (account) => {
return Promise.all((await this.helper.getAccounts()).map(async (account: string) => {
// await ocean.market.requestTokens(account, 1000)
return {
@ -43,21 +50,21 @@ export default class Ocean {
}))
}
async getOrdersByConsumer(consumerAddress) {
let accessConsentEvent = this.auth.contract.AccessConsentRequested({ _consumer: consumerAddress }, {
async getOrdersByConsumer(consumerAddress: string) {
let accessConsentEvent = this.auth.contract.AccessConsentRequested({_consumer: consumerAddress}, {
fromBlock: 0,
toBlock: 'latest'
})
let _resolve = null
let _reject = null
const promise = new Promise((resolve, reject) => {
let _resolve: Function = null
let _reject: Function = null
const promise = new Promise<any[]>((resolve, reject) => {
_resolve = resolve
_reject = reject
})
const getEvents = () => {
accessConsentEvent.get((error, logs) => {
const getEvents = (): Promise<any[]> => {
accessConsentEvent.get((error: any, logs: any[]) => {
if (error) {
_reject(error)
throw new Error(error)
@ -70,12 +77,13 @@ export default class Ocean {
const events = await getEvents().then((events) => events)
// let orders = await this.buildOrdersFromEvents(events, consumerAddress).then((result) => result)
let orders = events
.filter(obj => (obj.args._consumer === consumerAddress))
.map(async (event) => ({
.filter((obj: any) => (obj.args._consumer === consumerAddress))
.map(async (event: any) => ({
...event.args,
timeout: event.args._timeout.toNumber(),
status: await this.auth.getOrderStatus(event.args._id).then((status) => status.toNumber()),
paid: await this.market.verifyOrderPayment(event.args._id).then((received) => received),
status: await this.auth.getOrderStatus(event.args._id)
.then((status: BigNumber) => status.toNumber()),
paid: this.market.verifyOrderPayment(event.args._id),
key: null
}))
Logger.debug('got orders: ', orders)
@ -83,12 +91,12 @@ export default class Ocean {
}
async purchaseAsset(
assetId, publisherId, price, privateKey, publicKey, timeout, senderAddress,
initialRequestEventHandler, accessCommittedEventHandler, tokenPublishedEventHandler) {
const { token, market, auth } = this
assetId: string, publisherId: string, price: number, privateKey: string, publicKey: string, timeout: number, senderAddress: string,
initialRequestEventHandler: Function, accessCommittedEventHandler: Function, tokenPublishedEventHandler: Function) {
const {token: OceanToken, market: OceanMarket, auth} = this
try {
// Allow market contract to transfer funds on the consumer's behalf
await token.contract.approve(market.contract.address, price, { from: senderAddress, gas: 2000000 })
await this.token.contract.approve(this.market.contract.address, price, {from: senderAddress, gas: 2000000})
} catch (err) {
Logger.log('token approve', err)
}
@ -96,33 +104,33 @@ export default class Ocean {
// Submit the access request
await auth.contract.initiateAccessRequest(
assetId, publisherId, publicKey,
timeout, { from: senderAddress, gas: 1000000 }
timeout, {from: senderAddress, gas: 1000000}
)
} catch (err) {
Logger.log('initiateAccessRequest', err)
}
const resourceFilter = { _resourceId: assetId, _consumer: senderAddress }
const resourceFilter = {_resourceId: assetId, _consumer: senderAddress}
const initRequestEvent = auth.contract.AccessConsentRequested(resourceFilter)
let order = {}
let order: any = {}
this._listenOnce(
initRequestEvent,
'AccessConsentRequested',
(result, error) => {
(result: any, error: any) => {
order = initialRequestEventHandler(result, error)
const requestIdFilter = { _id: order.id }
const requestIdFilter = {_id: order.id}
const accessCommittedEvent = auth.contract.AccessRequestCommitted(requestIdFilter)
const tokenPublishedEvent = auth.contract.EncryptedTokenPublished(requestIdFilter)
this._listenOnce(
accessCommittedEvent,
'AccessRequestCommitted',
(result, error) => {
(result: any, error: any) => {
accessCommittedEventHandler(result, order, error)
}
)
this._listenOnce(
tokenPublishedEvent,
'EncryptedTokenPublished',
(result, error) => {
(result: any, error: any) => {
tokenPublishedEventHandler(result, order, error)
}
)
@ -131,9 +139,9 @@ export default class Ocean {
}
// Helper functions (private)
_listenOnce(event, eventName, callback) {
_listenOnce(event: any, eventName: string, callback: Function) {
// eslint-disable-next-line security/detect-non-literal-fs-filename
event.watch((error, result) => {
event.watch((error: any, result: any) => {
event.stopWatching()
if (error) {
Logger.log(`Error in keeper ${eventName} event: `, error)

11
src/squid.js
View File

@ -1,11 +0,0 @@
import OceanAgent from './deprecated/ocean-agent'
import OceanKeeper from './deprecated/ocean-keeper'
import Ocean from './ocean'
import Logger from './utils/logger'
export {
Ocean,
OceanAgent, // deprecated
OceanKeeper, // deprecated
Logger
}

7
src/squid.ts Normal file
View File

@ -0,0 +1,7 @@
import Ocean from './ocean'
import Logger from './utils/logger'
export {
Ocean,
Logger
}

24
src/utils/Web3Helper.js → src/utils/Web3Helper.ts
View File

@ -1,11 +1,16 @@
import Web3 = require("web3");
export default class Web3Helper {
constructor(web3) {
this.web3 = web3
public web3: Web3;
constructor(config: any) {
const web3Provider = config.web3Provider || new Web3.providers.HttpProvider(config.nodeUri)
this.web3 = new Web3(web3Provider)
}
async getAccounts() {
return new Promise((resolve, reject) => {
this.web3.eth.getAccounts((err, accounts) => {
async getAccounts(): Promise<any[]> {
return new Promise<any[]>((resolve: Function, reject: Function) => {
this.web3.eth.getAccounts((err: any, accounts: string[]) => {
if (err) {
throw err
}
@ -14,9 +19,10 @@ export default class Web3Helper {
})
}
async getNetworkName() {
return new Promise((resolve, reject) => {
let network = 'unknown'
async getNetworkName(): Promise<string> {
return new Promise<string>((resolve: Function, reject: Function) => {
let network: string = 'unknown'
// @ts-ignore old version of web3, lets get to 1.0
this.web3.version.getNetwork((err, networkId) => {
if (err) {
throw err
@ -46,7 +52,7 @@ export default class Web3Helper {
}
// web3 wrappers
sign(accountAddress, message) {
sign(accountAddress: string, message: string) {
return this.web3.eth.sign(accountAddress, message)
}
}

5
src/utils/config.ts Normal file
View File

@ -0,0 +1,5 @@
export default class Config {
public defaultGas: number = 300000;
public providerUri: string;
}

11
src/utils/logger.js → src/utils/logger.ts
View File

@ -1,22 +1,23 @@
export default class Logger {
static dispatch(verb, ...args) {
static dispatch(verb: string, ...args: any[]) {
/* eslint-disable-next-line no-console */
// @ts-ignore
console[verb](...args)
}
static log(...args) {
static log(...args: any[]) {
Logger.dispatch('log', ...args)
}
static debug(...args) {
static debug(...args: any[]) {
Logger.dispatch('debug', ...args)
}
static warn(...args) {
static warn(...args: any[]) {
Logger.dispatch('warn', ...args)
}
static error(...args) {
static error(...args: any[]) {
Logger.dispatch('error', ...args)
}
}

22
tsconfig.json Normal file
View File

@ -0,0 +1,22 @@
{
"compilerOptions": {
"lib": [
"es6",
"es7"
],
"module": "commonjs",
"noImplicitAny": false,
"removeComments": true,
"preserveConstEnums": true,
"outDir": "./dist/",
"rootDir": "./src/",
"sourceMap": true
},
"include": [
"src/**/*"
],
"exclude": [
"node_modules",
"**/*.spec.ts"
]
}