@com-chain/jsc3l 2.0.1-rc.7 → 2.0.1-rc.8

package/src/index.ts

@@ -1,5 +1,6 @@
 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'
@@ -17,8 +18,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,6 +40,7 @@ abstract class AbstractJsc3l {
   protected abstract persistentStore: t.IPersistentStore
 
   localDefaultConf: {}
+  defaultTransactionDefs: []
 
   endpoint: string
 
@@ -47,8 +49,9 @@ abstract class AbstractJsc3l {
   _http: null | HttpAbstract
 
 
-  constructor (localDefaultConf?) {
+  constructor (localDefaultConf?, defaultTransactionDefs?) {
     this.localDefaultConf = localDefaultConf || {}
+    this.defaultTransactionDefs = defaultTransactionDefs || localTransactionDefs
   }
 
   /**
@@ -163,23 +166,30 @@ 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]
@@ -188,7 +198,9 @@ abstract class AbstractJsc3l {
 
   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 +217,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,7 +237,9 @@ 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
+      ),
     }
   }
 }
@@ -230,7 +248,8 @@ abstract class AbstractJsc3l {
 Object.assign(AbstractJsc3l.prototype, {
   memo,
   ethFuncs,
-  createIcon
+  createIcon,
+  qr,
 })
 
 
@@ -354,7 +373,12 @@ abstract class IntegratedJsc3lAbstract extends AbstractJsc3l {
     }
     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()}/${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

@@ -80,14 +80,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.

package/src/wallet.ts

@@ -1,6 +1,7 @@
-import ethUtil from 'ethereumjs-util'
-
 import AjaxReq from './rest/ajaxReq'
+import {
+  checkSignedQR, SignedQR, makeSignedQRContent, makeSignedQRFragments
+} from './qr'
 import { shortenAddress, cipherMsg, decipherMsg } from './ethereum/cipher'
 import Wallet from './ethereum/myetherwallet'
 
@@ -121,10 +122,22 @@ export default abstract class MessagingWalletAbstract extends Wallet {
     })
   }
 
-  public enrollAddress (codeId, token) {
-    return this.ajaxReq.enrollAddress(
-      codeId, this.getAddressString(),
-      this.currencyName, token)
+  public validateEnrollment (id, signature) {
+    return this.ajaxReq.enrollPost({
+      id,
+      signature,
+      currency: this.currencyName,
+    })
+  }
+
+  public enrollAddress (id, token) {
+    return this.ajaxReq.enrollPost({
+      id,
+      token,
+      currency: this.currencyName,
+      // XXXvlab: Yes, typo is intentional here (in PHP API):
+      addresse: this.getAddressString(),
+    })
   }
 
   public requestUnlock () {
@@ -148,54 +161,38 @@ export default abstract class MessagingWalletAbstract extends Wallet {
     }
   }
 
-
   //
-  // QR Codes requires EthUtils
+  // QR Code helpers
   //
 
-  public makeSignedQRWithPubKey (objContent, pubKey) {
-    objContent.message_key = cipherMsg(
-      pubKey, this.messageKeysFromWallet()
-    )
-    objContent.address = this.getAddressString()
-    return this.makeSignedQR(objContent)
+  public makeSignedQRContent (obj, pubKey: string | null) {
+    return makeSignedQRContent({
+      server: this.currencyName,
+      address: this.getAddressString(),
+      ...obj,
+      ...pubKey && {
+        message_key: cipherMsg(pubKey, this.messageKeysFromWallet())
+      },
+    }, this.privKey)
   }
 
-  public makeSignedQR (obj) {
-
-    // Values expected:
-    const {
-      server, destinary, begin, end,
-      viewbalance, viewoldtran, pub_key
-    } = obj
-    const formatDate = (date) =>
-      `${begin.getFullYear()}/${begin.getMonth()}/${begin.getDate()}`
-    const objContent = Object.assign(obj, {
-      address: this.getAddressString(),
-      begin: formatDate(begin),
-      end: formatDate(end)
-    })
+  public makeSignedQRFragments (
+    obj, fragmentCount: number, pubKey: string | null
+  ) {
+    return makeSignedQRFragments(
+      this.makeSignedQRContent(obj, pubKey),
+      fragmentCount,
+    )
+  }
 
-    const hash = ethUtil.sha3(JSON.stringify(objContent))
-    const signature = ethUtil.ecsign(hash, this.privKey)
-    return {
-      signature,
-      qrContent: JSON.stringify({
-        data: objContent,
-        signature: {
-          v: signature.v,
-          r: '0x' + signature.r.toString('hex'),
-          s: '0x' + signature.s.toString('hex')
-        }
-      })
+  public checkSignedQRFromString (qrString: string) {
+    let qrContent: SignedQR
+    try {
+      qrContent = JSON.parse(qrString)
+    } catch (e) {
+      return 'InvalidFormat'
     }
+    return checkSignedQR(qrContent, this.getAddressString())
   }
 
 }
-
-// // TODO: What to do with this validateEnrollment
-// public static validateEnrollment (codeId, signature) {
-//     return this.ajaxReq.validateEnrollmentLetter(
-//       codeId, this.currencyName, signature)
-//   }
-