@com-chain/jsc3l 2.0.1-rc.0

package/src/index.ts

@@ -0,0 +1,366 @@
+import * as ethFuncs from './ethereum/ethFuncs'  // Utilities to pass on
+import * as memo from './memo'
+
+// Only required for blockie helper
+import blockies from './blockies'
+import Wallet from './ethereum/myetherwallet'
+
+import * as t from './type'
+
+
+// Abstracts
+
+import HttpAbstract from './rest/http'
+import EndpointAbstract from './rest/endpoint'
+import AjaxReqAbstract from './rest/ajaxReq'
+import ConnectionMgrAbstract from './connection'
+import CustomizationAbstract from './customization'
+import MessagingWalletAbstract from './wallet'
+import BcReadAbstract from './bcRead'
+import BcTransactionAbstract from './bcTransaction'
+
+
+
+function createIcon (address: string | Wallet) {
+  if (address instanceof Wallet) {
+    address = address.getAddressString()
+  }
+  return blockies({
+    seed: address.toLowerCase(),
+    size: 8,
+    scale: 16
+  }).toDataURL()
+}
+
+
+abstract class AbstractJsc3l {
+
+  protected abstract httpRequest: t.HttpRequest
+  protected abstract persistentStore: t.IPersistentStore
+
+  localDefaultConf: {}
+
+  endpoint: string
+
+  _Endpoint: new (baseUrl: any) => EndpointAbstract
+  _connection: null | ConnectionMgrAbstract
+  _http: null | HttpAbstract
+
+
+  constructor (localDefaultConf?) {
+    this.localDefaultConf = localDefaultConf || {}
+  }
+
+  /**
+   * `connection` facility needs to be lazy loaded as `this` and
+   * abstract `httpRequest` is not available in constructor.
+   */
+  get connection () {
+    if (!this._connection) {
+      const self = this
+      class ConnectionMgr extends ConnectionMgrAbstract {
+        http = self.http
+        persistentStore = self.persistentStore
+      }
+      this._connection = new ConnectionMgr()
+    }
+    return this._connection
+  }
+
+  /**
+   * `Endpoint` class is a facility that needs to be lazy loaded as
+   * `this` and abstract `httpRequest` is not available in
+   * constructor.
+   */
+  get Endpoint () {
+    if (!this._Endpoint) {
+      const self = this
+      class Endpoint extends EndpointAbstract {
+        httpRequest = self.httpRequest
+      }
+      this._Endpoint = Endpoint
+    }
+    return this._Endpoint
+  }
+
+  /**
+   * 'http' facility needs to be lazy loaded as 'this' and abstract
+   * httpRequest is not available in constructor.
+   */
+  get http () {
+    if (!this._http) {
+      const self = this
+      // ConnectionMgr
+
+      class Http extends HttpAbstract {
+        httpRequest = self.httpRequest
+      }
+      this._http = new Http()
+    }
+    return this._http
+  }
+
+
+
+  getAjaxReq (endpointUrl: string): AjaxReqAbstract {
+    const self = this
+    class AjaxReq extends AjaxReqAbstract {
+      endpoint = new self.Endpoint(endpointUrl)
+    }
+    return new AjaxReq()
+  }
+
+  /**
+   * `getConfJson` check persistent storage for configuration for
+   * given currency, otherwise will use the given repo to fetch
+   * it (and save it in persistent storage).
+   */
+  async getConfig (repo: string, currencyName: string) {
+    const cfgJson = this.connection.getLocalConfJSON()
+    if (cfgJson && cfgJson.server.name === currencyName) {
+      return cfgJson
+    }
+    return await this.connection.getConfJSON(currencyName, repo)
+  }
+
+
+  /**
+   * `getConfJson` check persistent storage for configuration for
+   * given currency, otherwise will use the given repo to fetch
+   * it (and save it in persistent storage).
+   */
+  getCustomization (config: any): CustomizationAbstract {
+    class Customization extends CustomizationAbstract {
+      cfg = config
+    }
+    return new Customization(this.localDefaultConf)
+  }
+
+
+  getWallet (
+    endpointUrl: string,
+    currencyName: string,
+    unlockUrl: string): new () => MessagingWalletAbstract {
+
+    const self = this
+    class MessagingWallet extends MessagingWalletAbstract {
+      ajaxReq = self.getAjaxReq(endpointUrl)
+      currencyName = currencyName
+      unlockUrl = unlockUrl
+    }
+    // XXXvlab: should we instanciate this ?
+    return MessagingWallet
+  }
+
+
+  getBcRead (endpointUrl, contracts): BcReadAbstract {
+    const self = this
+    class BcRead extends BcReadAbstract {
+      ajaxReq = self.getAjaxReq(endpointUrl)
+      contracts = contracts
+    }
+    return new BcRead()
+  }
+
+
+  getBcTransaction (endpointUrl, contracts): BcTransactionAbstract {
+    const self = this
+    class BcTransaction extends BcTransactionAbstract {
+      ajaxReq = self.getAjaxReq(endpointUrl)
+      contracts = contracts
+    }
+    return new BcTransaction()
+  }
+
+
+  _currencyMgrPromises = {}
+  async getCurrencyMgr (currencyName: string, endpointUrl?: string, repoUrl?: string) {
+    const key = Array.from(arguments).join('\0')
+
+    if (!this._currencyMgrPromises[key]) {
+      this._currencyMgrPromises[key] =
+        this._getCurrencyMgr(currencyName, endpointUrl, repoUrl)
+    }
+
+    return await this._currencyMgrPromises[key]
+  }
+
+
+  async _getCurrencyMgr (currencyName: string,
+                         endpointUrl?: string,
+                         repoUrl?: string): Promise<any> {
+    if (!repoUrl) {
+      if (this.connection.repo) {
+        repoUrl = this.connection.repo
+      } else {
+        repoUrl = await this.connection.lookupAvailableComChainRepo()
+      }
+    }
+
+    if (!endpointUrl) {
+      if (this.connection.endpoint) {
+        endpointUrl = this.connection.endpoint
+      } else {
+        endpointUrl = (await this.connection.acquireEndPoint(repoUrl)).endpoint
+      }
+    }
+
+    const config = await this.getConfig(repoUrl, currencyName)
+    const customization = this.getCustomization(config)
+    const contracts = [
+      customization.getContract1(),
+      customization.getContract2()
+    ]
+
+    const self = this
+    const wallet = this.getWallet(
+        endpointUrl, currencyName, customization.getUnlockUrl())
+    return {
+      // unlockWallet: (jsonData, password) => wallet.getWalletFromPrivKeyFile(jsonData, password),
+      jsc3l: this,
+      customization,
+      ajaxReq: this.getAjaxReq(endpointUrl),
+      wallet: wallet,
+      bcRead: this.getBcRead(endpointUrl, contracts),
+      bcTransaction: this.getBcTransaction(endpointUrl, contracts),
+    }
+  }
+}
+
+
+
+
+
+
+Object.assign(AbstractJsc3l.prototype, {
+  memo,
+  ethFuncs,
+  createIcon
+})
+
+
+abstract class IntegratedJsc3lAbstract extends AbstractJsc3l {
+
+  /**
+   * `ajaxReq` depends on a loaded endpoint in
+   * `this.connection.endpoint` obtained through
+   * `this.endpoint.acquireEndPoint(..)`.  XXXvlab: We could cache the
+   * result with endpoint being a key.
+   */
+  get ajaxReq (): AjaxReqAbstract {
+    if (!this.connection.endpoint) {
+      throw new Error('An endpoint need to have been acquired.')
+    }
+    return this.getAjaxReq(this.connection.endpoint)
+  }
+
+
+  /**
+   * `customization` depends on a local configuration being available
+   * through a previous call to `this.connection.getConfJSON(..)`
+   *
+   * XXXvlab: We could cache the result with result of
+   * `connection.getLocalConf()` being the key.
+   */
+  get customization (): CustomizationAbstract {
+    // XXXvlab: Probably don't need a module for that, as the configuration
+    // is always re-queried and quite small, we could cache-it in memory.
+    const localCfg = this.connection.getLocalConfJSON()
+    if (!localCfg) {
+      throw new Error('No configuration is available locally.')
+    }
+
+    return this.getCustomization(localCfg)
+  }
+
+
+  /**
+   * `wallet` depends on both:
+   * - a local configuration (only for the `currencyName`) being
+   *   available through a previous call to
+   *   `this.connection.getConfJSON(..)`
+   * - a loaded endpoint in `this.connection.endpoint` obtained
+   *   through `this.endpoint.acquireEndPoint(..)`.
+   *
+   * XXXvlab: We could cache the result with result of
+   * `connection.getLocalConf()` and `this.connection.endpoint` being
+   * the keys.
+   */
+  get wallet (): MessagingWalletAbstract["constructor"] {
+    if (!this.ajaxReq) {
+      throw Error('a connect() is required before accessing wallet')
+    }
+    let localCfg: any
+    try {
+      localCfg = this.customization
+    } catch (e) {
+      throw Error('A local conf needs to be available before accessing wallet')
+    }
+    return this.getWallet(
+      this.ajaxReq.endpoint.baseUrl,
+      localCfg.getCurrencyName(),
+      this.customization.getUnlockUrl())
+  }
+
+
+  /**
+   * `bcRead` access depends on both:
+   * - a local configuration (only for contracts information) being
+   *   available through a previous call to
+   *   `this.connection.getConfJSON(..)`
+   * - a loaded endpoint in `this.connection.endpoint` obtained through
+   *   `this.endpoint.acquireEndPoint(..)`.
+   *
+   * XXXvlab: We could cache the result with result of
+   * `connection.getLocalConf()` and `this.connection.endpoint` being
+   * the keys.
+   */
+  get bcRead (): BcReadAbstract {
+    if (!this.ajaxReq) {
+      throw Error('an init() is required before accessing bcRead')
+    }
+    let localCfg: any
+    try {
+      localCfg = this.customization
+    } catch (e) {
+      throw Error('A local conf needs to be available before accessing wallet')
+    }
+    return this.getBcRead(
+      this.ajaxReq.endpoint.baseUrl,
+      [localCfg.getContract1(), localCfg.getContract2()]
+    )
+  }
+
+
+  /**
+   * `bcTransaction` access depends on both:
+   * - a local configuration (only for contracts information) being
+   *   available through a previous call to
+   *   `this.connection.getConfJSON(..)`
+   * - a loaded endpoint in `this.connection.endpoint` obtained through
+   *   `this.endpoint.acquireEndPoint(..)`.
+   *
+   * XXXvlab: We could cache the result with result of
+   * `connection.getLocalConf()` and `this.connection.endpoint` being
+   * the keys.
+   */
+  get bcTransaction (): BcTransactionAbstract {
+    if (!this.ajaxReq) {
+      throw Error('an init() is required before accessing bcTransaction')
+    }
+    let localCfg: any
+    try {
+      localCfg = this.customization
+    } catch (e) {
+      throw Error('A local conf needs to be available before accessing wallet')
+    }
+    return this.getBcTransaction(
+      this.ajaxReq.endpoint.baseUrl,
+      [localCfg.getContract1(), localCfg.getContract2()]
+    )
+  }
+
+}
+
+
+export default IntegratedJsc3lAbstract

package/src/memo.ts

@@ -0,0 +1,37 @@
+import { cipherMsg, decipherMsg } from './ethereum/cipher'
+
+
+// Used in the test
+export function getMyTransactionMemo (msgWallet, transaction) {
+  const key = msgWallet.messageKeysFromWallet()
+  const watchedAddress = msgWallet.getAddressString().toLowerCase()
+  const { addr_to, message_to, addr_from, message_from } = transaction
+
+  return getTransactionMemo(transaction, watchedAddress, key)
+}
+
+
+export function getTransactionMemo (transaction, forAddress, messageKey) {
+  const { addr_to, message_to, addr_from, message_from } = transaction
+
+  if (addr_to.toLowerCase() === forAddress && message_to) {
+    return decipherMsg(messageKey, message_to)
+  }
+
+  if (addr_from.toLowerCase() === forAddress && message_from) {
+    return decipherMsg(messageKey, message_from)
+  }
+
+  return ''
+}
+
+
+export function getTxMemoCipheredData (fromMsgKey, toMsgKey, msgFrom, msgTo) {
+  return {
+    ...(fromMsgKey && msgFrom) &&
+      { memo_from: cipherMsg(fromMsgKey, msgFrom) },
+    ...(toMsgKey && msgTo) &&
+      { memo_to: cipherMsg(toMsgKey, msgTo) },
+  }
+}
+

package/src/qr.ts

@@ -0,0 +1,34 @@
+import ethUtil from 'ethereumjs-util'
+
+
+export function checkSignedQRFromString (qrString, intendedRecipientAddress) {
+  let data:string, signature: string
+  try {
+    ({ data, signature } = JSON.parse(qrString))
+  } catch (e) {
+    return 'InvalidFormat'
+  }
+  return checkSignedQR(data, signature, intendedRecipientAddress)
+}
+
+export function checkSignedQR (data, signature, intendedRecipientAddress) {
+  let hash: string
+  let publicSignKey: string
+  let receiverAddress: string
+  try {
+    hash = ethUtil.sha3(JSON.stringify(data))
+    publicSignKey = ethUtil.ecrecover(
+      hash, signature.v, signature.r, signature.s)
+    receiverAddress = ethUtil.bufferToHex(
+      ethUtil.publicToAddress(publicSignKey))
+  } catch (e) {
+    return 'InvalidFormat'
+  }
+
+  if (receiverAddress !== data.address) { return 'InvalidSignature' }
+  if (data.destinary !== intendedRecipientAddress) { return 'NotForYou' }
+  if ((new Date(data.end)).getTime() < (new Date()).getTime()) {
+    return 'Expired'
+  }
+  return { signature, data }
+}

package/src/rest/ajaxReq.ts

@@ -0,0 +1,160 @@
+
+class URL {
+  static SERVER = 'api.php';
+  static ENROLL = 'enroll.php';
+  static TRANLIST = 'trnslist.php';
+  static TRANCHECK = 'api.php';
+  static EXPORTTRAN = 'export.php';
+  static GETCODE = 'getuid.php';
+  static GETADDRESS = 'getadd.php';
+  static KEYSTORE = 'keys.php';
+  static requestMessages = 'requestMessages.php';
+}
+
+
+export default abstract class AjaxReqAbstract {
+
+  // XXXvlab: need to be public only to allow integrated mode (used in
+  // ``jsc3l.wallet``)
+  public abstract endpoint: any
+
+  pendingPosts = []
+
+  //
+  // URL.SERVER POST requests (that are using queuing mecanism)
+  //
+
+  post (data) {
+    const self = this
+    return new Promise(function (resolve, reject) {
+      self.pendingPosts.push({ data, resolve, reject })
+      if (self.pendingPosts.length === 1) self.queuePost()
+    })
+  }
+
+  queuePost () {
+    const { data, resolve, reject } = this.pendingPosts[0]
+
+    try {
+      this.endpoint.post(URL.SERVER, data).then(data => {
+        resolve(data.data)
+      })
+    } catch (err) {
+      console.log(err)
+      reject(err)
+    }
+    this.pendingPosts.splice(0, 1)
+    if (this.pendingPosts.length > 0) { this.queuePost() }
+  }
+
+
+  getBalance (addr) { return this.post({ balance: addr }) }
+  getTransactionData (addr) { return this.post({ txdata: addr }) }
+  async sendTx (rawTx, additionalData) {
+    const data: {[k: string]: any} =
+      await this.post(Object.assign({}, { rawtx: rawTx }, additionalData ?? {}))
+
+    return {
+      isError: !!data.error,
+      error: data.error ? data.data : data.msg
+    }
+  }
+
+
+  getEstimatedGas (txobj) { return this.post({ estimatedGas: txobj }) }
+  getEthCall (txobj) { return this.post({ ethCall: txobj }) }
+
+  getEthCallAt (txobj, blockNb) {
+    return this.post({ ethCallAt: txobj, blockNb })
+  }
+
+
+  //
+  // Other calls
+  //
+
+  enrollPost (data) {
+    return this.endpoint.post(URL.ENROLL, { data: JSON.stringify(data) })
+  }
+
+  validateEnrollmentLetter (id, currency, signature) {
+    return this.enrollPost({ id, currency, signature })
+  }
+
+  enrollAddress (id, address, currency, token) {
+    return this.enrollPost({ id, addresse: address, token, currency })
+  }
+
+  async getTransList (id, count, offset) {
+    // for some strange reasons, the answer is stringified 2 times,
+    // so we need to unpack each entry a second time.
+    const data = await this.endpoint.get(URL.TRANLIST, { addr: id, count, offset })
+    return data.map((dataJSON) => JSON.parse(dataJSON))
+  }
+
+  getTransCheck (hash) {
+    return this.endpoint.get(URL.TRANCHECK, { hash })
+  }
+
+  getExportTransList (id, start, end) {
+    return this.endpoint.get(URL.EXPORTTRAN, { addr: id, start, end })
+  }
+
+  getExportTransListWithId (id, start, end) {
+    return this.endpoint.get(URL.EXPORTTRAN, { addr: id, start, end })
+  }
+
+  getCodesFromAddresses (addresses, currency, caller, signature) {
+    return this.endpoint.post(URL.GETCODE, {
+      server: currency,
+      caller,
+      signature,
+      addresses
+    })
+  }
+
+  getAddressesFromCode (code, currency, caller, signature) {
+    return this.endpoint.post(URL.GETADDRESS, {
+      server: currency,
+      caller,
+      signature,
+      code
+    })
+  }
+
+  getMessageKey (addr, withPrivate) {
+    const data: {[k: string]: any} = { addr }
+    if (withPrivate) data.private = '1'
+    return this.endpoint.get(URL.KEYSTORE, data)
+  }
+
+  publishMessageKey (data, sign) {
+    return this.endpoint.post(URL.KEYSTORE, { data, sign })
+  }
+
+  requestUnlock (address, url) {
+    return this.endpoint.post(url, { address })
+  }
+
+  getReqMessages (addFrom, addTo) {
+    return this.endpoint.get(
+      URL.requestMessages,
+      { add_req: addFrom, add_cli: addTo })
+  }
+
+  publishReqMessages (data, sign) {
+    return this.endpoint.post(URL.requestMessages, { data, sign })
+  }
+
+  currBlock () { return this.endpoint.get(URL.SERVER) }
+
+  async getBlock (hash) {
+    let res = await this.endpoint.get(URL.SERVER, { hash })
+    if (res && typeof res !== 'object') {
+      res = JSON.parse(res).transaction
+    }
+    return res
+  }
+
+}
+

package/src/rest/endpoint.ts

@@ -0,0 +1,31 @@
+import HttpAbstract from './http'
+import postSerializer from './serializer'
+
+/**
+ * Serialize data, adds default config and transfer to code http module
+ *
+ */
+abstract class PostSerializedHttpAbstract extends HttpAbstract {
+  post (...[url, data, opts]: any[]) {
+    return super.post(url, postSerializer(data), opts)
+  }
+}
+
+/**
+ * Prepend endpoint address to url, and support passing data to
+ * querystring when method is GET.
+ */
+export default abstract class EndpointAbstract extends PostSerializedHttpAbstract {
+
+  baseUrl: string
+
+  constructor (baseUrl) {
+    super()
+    this.baseUrl = baseUrl
+  }
+
+  request (method, url, ...args: any[]) {
+    url = url.includes('://') ? url : this.baseUrl + url
+    return super.request(method, url, ...args)
+  }
+}

package/src/rest/http.ts

@@ -0,0 +1,69 @@
+import * as t from '../type'
+
+
+function getHostOrUrlParts (HostOrUrl: string): t.UrlParts {
+  let protocol: string, host: string, port: number, path: string
+  if (HostOrUrl.includes('://')) {
+    ;[protocol, HostOrUrl] = HostOrUrl.split('://')
+  } else {
+    protocol = 'https'
+    HostOrUrl = HostOrUrl.replace(/\/$/, '')
+  }
+  if (HostOrUrl.includes('/')) {
+    const splits = HostOrUrl.split('/')
+    ;[host, path] = [splits[0], '/' + splits.slice(1).join('/')]
+  } else {
+    // assume host only
+    path = ''
+    host = HostOrUrl
+  }
+  if (host.includes(':')) {
+    const splits = host.split(':')
+    if (splits.length > 2) {
+      throw new Error(`Too many ':' to get host and port: ${host}`)
+    }
+    ;[host, port] = [splits[0], parseInt(splits[1])]
+  } else {
+    if (protocol === 'http') {
+      port = 80
+    } else if (protocol === 'https') {
+      port = 443
+    } else {
+      throw new Error(
+        `Could not infer port from unknown protocol ${protocol}`
+      )
+    }
+  }
+  return {
+    protocol,
+    host,
+    port,
+    path,
+  }
+}
+
+
+/**
+ * Support passing data to querystring when method is GET.
+ */
+export default abstract class HttpAbstract {
+
+  protected abstract httpRequest: t.HttpRequest
+
+  async request (...[method, url, data, opts]: any[]) {
+    if (method === 'GET' && data && Object.keys(data).length > 0) {
+      url += '?' + (new URLSearchParams(data)).toString()
+    }
+
+    var coreOpts = {
+      method,
+      data: method === 'GET' ? null : data,
+      ...opts,
+      ...getHostOrUrlParts(url)
+    }
+    return await <any> this.httpRequest(coreOpts)
+  }
+
+  get (...args: any[]) { return this.request('GET', ...args) }
+  post (...args: any[]) { return this.request('POST', ...args) }
+}