@com-chain/jsc3l 2.0.1-rc.2 → 2.0.1-rc.20

package/src/index.ts

@@ -1,9 +1,11 @@
 import * as ethFuncs from './ethereum/ethFuncs'  // Utilities to pass on
 import * as memo from './memo'
+import * as qr from './qr'
 
 // Only required for blockie helper
 import blockies from './blockies'
 import Wallet from './ethereum/myetherwallet'
+import * as utils from './utils'
 
 import * as t from './type'
 
@@ -17,8 +19,8 @@ import ConnectionMgrAbstract from './connection'
 import CustomizationAbstract from './customization'
 import MessagingWalletAbstract from './wallet'
 import BcReadAbstract from './bcRead'
-import BcTransactionAbstract from './bcTransaction'
-
+import { BcTransactionAbstract, transactionFactory } from './bcTransaction'
+import localTransactionDefs from './config/transactions'
 
 
 function createIcon (address: string | Wallet) {
@@ -39,16 +41,18 @@ abstract class AbstractJsc3l {
   protected abstract persistentStore: t.IPersistentStore
 
   localDefaultConf: {}
+  defaultTransactionDefs: []
 
   endpoint: string
 
   _Endpoint: new (baseUrl: any) => EndpointAbstract
   _connection: null | ConnectionMgrAbstract
   _http: null | HttpAbstract
+  utils = utils
 
-
-  constructor (localDefaultConf?) {
+  constructor (localDefaultConf?, defaultTransactionDefs?) {
     this.localDefaultConf = localDefaultConf || {}
+    this.defaultTransactionDefs = defaultTransactionDefs || localTransactionDefs
   }
 
   /**
@@ -117,7 +121,7 @@ abstract class AbstractJsc3l {
    */
   async getConfig (repo: string, currencyName: string) {
     const cfgJson = this.connection.getLocalConfJSON()
-    if (cfgJson && cfgJson.server.name === currencyName) {
+    if (cfgJson && cfgJson.server?.name === currencyName) {
       return cfgJson
     }
     return await this.connection.getConfJSON(currencyName, repo)
@@ -163,32 +167,46 @@ abstract class AbstractJsc3l {
   }
 
 
-  getBcTransaction (endpointUrl, contracts): BcTransactionAbstract {
+  getBcTransaction (
+    endpointUrl, contracts, transactionDefs
+  ): BcTransactionAbstract {
     const self = this
     class BcTransaction extends BcTransactionAbstract {
       ajaxReq = self.getAjaxReq(endpointUrl)
       contracts = contracts
     }
+    transactionFactory(transactionDefs, BcTransaction)
     return new BcTransaction()
   }
 
 
   _currencyMgrPromises = {}
-  async getCurrencyMgr (currencyName: string, endpointUrl?: string, repoUrl?: string) {
-    const key = Array.from(arguments).join('\0')
+  async getCurrencyMgr (
+    currencyName: string, endpointUrl?: string, repoUrl?: string,
+    transactionDefs?: any[],
+  ) {
+
+    const key = JSON.stringify(Array.from(arguments))
 
     if (!this._currencyMgrPromises[key]) {
       this._currencyMgrPromises[key] =
-        this._getCurrencyMgr(currencyName, endpointUrl, repoUrl)
+        this._getCurrencyMgr(currencyName, endpointUrl, repoUrl, transactionDefs)
     }
 
-    return await this._currencyMgrPromises[key]
-  }
+    try {
+      return await this._currencyMgrPromises[key]
+    } catch(e) {
+      delete this._currencyMgrPromises[key]
+      throw e
+    }
 
+  }
 
   async _getCurrencyMgr (currencyName: string,
                          endpointUrl?: string,
-                         repoUrl?: string): Promise<any> {
+                         repoUrl?: string,
+                         transactionDefs?: any[],
+                        ): Promise<any> {
     if (!repoUrl) {
       if (this.connection.repo) {
         repoUrl = this.connection.repo
@@ -205,15 +223,19 @@ abstract class AbstractJsc3l {
       }
     }
 
+    transactionDefs = transactionDefs || localTransactionDefs
+
     const config = await this.getConfig(repoUrl, currencyName)
     const customization = this.getCustomization(config)
     const contracts = [
       customization.getContract1(),
-      customization.getContract2()
+      customization.getContract2(),
+      customization.getContract3()
     ]
 
     const wallet = this.getWallet(
-        endpointUrl, currencyName, customization.getUnlockUrl())
+      endpointUrl, currencyName, customization.getUnlockUrl()
+    )
     return {
       // unlockWallet: (jsonData, password) => wallet.getWalletFromPrivKeyFile(jsonData, password),
       jsc3l: this,
@@ -221,20 +243,19 @@ abstract class AbstractJsc3l {
       ajaxReq: this.getAjaxReq(endpointUrl),
       wallet: wallet,
       bcRead: this.getBcRead(endpointUrl, contracts),
-      bcTransaction: this.getBcTransaction(endpointUrl, contracts),
+      bcTransaction: this.getBcTransaction(
+        endpointUrl, contracts, transactionDefs
+      ),
     }
   }
 }
 
 
-
-
-
-
 Object.assign(AbstractJsc3l.prototype, {
   memo,
   ethFuncs,
-  createIcon
+  createIcon,
+  qr,
 })
 
 
@@ -290,13 +311,13 @@ abstract class IntegratedJsc3lAbstract extends AbstractJsc3l {
    */
   get wallet (): MessagingWalletAbstract["constructor"] {
     if (!this.ajaxReq) {
-      throw Error('a connect() is required before accessing wallet')
+      throw new 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')
+      throw new Error('A local conf needs to be available before accessing wallet')
     }
     return this.getWallet(
       this.ajaxReq.endpoint.baseUrl,
@@ -319,13 +340,13 @@ abstract class IntegratedJsc3lAbstract extends AbstractJsc3l {
    */
   get bcRead (): BcReadAbstract {
     if (!this.ajaxReq) {
-      throw Error('an init() is required before accessing bcRead')
+      throw new 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')
+      throw new Error('A local conf needs to be available before accessing wallet')
     }
     return this.getBcRead(
       this.ajaxReq.endpoint.baseUrl,
@@ -348,17 +369,22 @@ abstract class IntegratedJsc3lAbstract extends AbstractJsc3l {
    */
   get bcTransaction (): BcTransactionAbstract {
     if (!this.ajaxReq) {
-      throw Error('an init() is required before accessing bcTransaction')
+      throw new 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')
+      throw new Error('A local conf needs to be available before accessing wallet')
     }
     return this.getBcTransaction(
       this.ajaxReq.endpoint.baseUrl,
-      [localCfg.getContract1(), localCfg.getContract2()]
+      [
+        localCfg.getContract1(),
+        localCfg.getContract2(),
+        localCfg.getContract3(),
+      ],
+      this.defaultTransactionDefs
     )
   }
 

package/src/qr.ts

@@ -1,20 +1,43 @@
 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)
+
+type Signature = {
+  v: string,
+  r: string,
+  s: string,
+}
+
+type QRDataRaw = {
+  address: string,
+  destinary: string,
+  begin: string,
+  end: string,
+  viewbalance: boolean,
+  viewoldtran: boolean,
+  message_key?: string,
+}
+
+type QRData = {
+  address: string,
+  destinary: string,
+  begin: Date,
+  end: Date,
+  viewbalance: boolean,
+  viewoldtran: boolean,
+  message_key?: string,
 }
 
-export function checkSignedQR (data, signature, intendedRecipientAddress) {
+
+export type SignedQR = {data: QRDataRaw, signature: Signature}
+
+
+export function checkSignedQR (qrContent: SignedQR, intendedRecipientAddress) {
+
   let hash: string
   let publicSignKey: string
   let receiverAddress: string
+  const { data, signature } = qrContent
   try {
     hash = ethUtil.sha3(JSON.stringify(data))
     publicSignKey = ethUtil.ecrecover(
@@ -22,13 +45,64 @@ export function checkSignedQR (data, signature, intendedRecipientAddress) {
     receiverAddress = ethUtil.bufferToHex(
       ethUtil.publicToAddress(publicSignKey))
   } catch (e) {
+    // XXXVlab: should probably use exceptions
     return 'InvalidFormat'
   }
 
-  if (receiverAddress !== data.address) { return 'InvalidSignature' }
-  if (data.destinary !== intendedRecipientAddress) { return 'NotForYou' }
+  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 }
+  return true
+}
+
+
+export function makeSignedQRFragments (
+  qrContent: SignedQR,
+  fragmentCount: number
+) {
+
+  const signatureId = qrContent.signature.s.substring(4, 8)
+
+  const qrString = JSON.stringify(qrContent)
+  const fragmentSize = Math.ceil(qrString.length / fragmentCount)
+  const fragments = {
+    full: qrString,
+  }
+
+  for (let i = 0; i < fragmentCount; i++) {
+    fragments[i] = `FRAG_CR${signatureId}${i}${qrString.substring(
+      fragmentSize * i,
+      Math.min(fragmentSize * (i + 1), qrString.length)
+    )}`
+  }
+
+  return fragments
+}
+
+
+export function makeSignedQRContent (obj: QRData, privKey: string): SignedQR {
+  const { begin, end } = obj
+  const formatDate = (date: Date) =>
+    `${date.getFullYear()}/${(date.getMonth()+1)}/${date.getDate()}`
+  const data = Object.assign(obj, {
+    begin: formatDate(begin),
+    end: formatDate(end),
+  })
+
+  const hash = ethUtil.sha3(JSON.stringify(data))
+  const { v, r, s } = ethUtil.ecsign(hash, privKey)
+  const signature = {
+    v,
+    r: '0x' + r.toString('hex'),
+    s: '0x' + s.toString('hex'),
+  }
+
+  return { data, signature }
+
 }

package/src/rest/ajaxReq.ts

@@ -1,9 +1,10 @@
 
+import { APIError } from '../exception'
+
 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';
@@ -35,14 +36,13 @@ export default abstract class AjaxReqAbstract {
   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.endpoint.post(URL.SERVER, data).then(res => {
+      if (res.error) {
+        reject(new APIError(res.msg, res.data))
+        return
+      }
+      resolve(res.data)
+    })
     this.pendingPosts.splice(0, 1)
     if (this.pendingPosts.length > 0) { this.queuePost() }
   }
@@ -50,18 +50,7 @@ export default abstract class AjaxReqAbstract {
 
   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 }) }
+  sendTx (rawTx, more) { return this.post({ rawtx: rawTx, ...(more ?? {}) }) }
   getEthCall (txobj) { return this.post({ ethCall: txobj }) }
 
   getEthCallAt (txobj, blockNb) {
@@ -77,14 +66,6 @@ export default abstract class AjaxReqAbstract {
     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.
@@ -92,16 +73,9 @@ export default abstract class AjaxReqAbstract {
     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 })
+  async getExportTransList (id, start, end) {
+    const data = await this.endpoint.get(URL.EXPORTTRAN, { addr: id, start, end })
+    return data.map((dataJSON) => JSON.parse(dataJSON))
   }
 
   getCodesFromAddresses (addresses, currency, caller, signature) {
@@ -149,9 +123,13 @@ export default abstract class AjaxReqAbstract {
   currBlock () { return this.endpoint.get(URL.SERVER) }
 
   async getBlock (hash) {
+    return (await this.getTransactionInfo(hash)).transaction
+  }
+
+  async getTransactionInfo (hash) {
     let res = await this.endpoint.get(URL.SERVER, { hash })
     if (res && typeof res !== 'object') {
-      res = JSON.parse(res).transaction
+      res = JSON.parse(res)
     }
     return res
   }