@com-chain/jsc3l 2.0.1-rc.1 → 2.0.1-rc.10

package/src/ethereum/ethFuncs.ts

@@ -36,7 +36,7 @@ function padLeftEven (hex) {
 }
 
 export function addTinyMoreToGas (hex) {
-  hex = this.sanitizeHex(hex)
+  hex = sanitizeHex(hex)
   return new BigNumber(hex).plus(etherUnits.getValueOfUnit('gwei'))
     .toDigits(2).toString(16)
 }

package/src/ethereum/etherUnits.ts

@@ -41,26 +41,26 @@ export function getValueOfUnit (unit) {
 export function fiatToWei (number, pricePerEther) {
   return new BigNumber(String(number))
     .div(pricePerEther)
-    .times(this.getValueOfUnit('ether'))
+    .times(getValueOfUnit('ether'))
     .round(0)
     .toString(10)
 }
 
 export function toFiat (number, unit, multi) {
-  return new BigNumber(this.toEther(number, unit))
+  return new BigNumber(toEther(number, unit))
     .times(multi)
     .round(5)
     .toString(10)
 }
 
 export function toEther (number, unit) {
-  return new BigNumber(this.toWei(number, unit))
-    .div(this.getValueOfUnit('ether'))
+  return new BigNumber(toWei(number, unit))
+    .div(getValueOfUnit('ether'))
     .toString(10)
 }
 
 export function toWei (number, unit) {
   return new BigNumber(String(number))
-    .times(this.getValueOfUnit(unit))
+    .times(getValueOfUnit(unit))
     .toString(10)
 }

package/src/ethereum/uiFuncs.ts

@@ -24,32 +24,23 @@ function isTxDataValid (txData) {
 }
 
 export function generateTx (txData, data) {
-  try {
-    isTxDataValid(txData)
+  isTxDataValid(txData)
 
-    const rawTx: {[k: string]: any} = {
-      nonce: ethFuncs.sanitizeHex(data.nonce),
-      gasPrice: ethFuncs.sanitizeHex(
-        ethFuncs.addTinyMoreToGas(data.gasprice)),
-      gasLimit: ethFuncs.sanitizeHex(
-        ethFuncs.decimalToHex(txData.gasLimit)),
-      to: ethFuncs.sanitizeHex(txData.to),
-      value: ethFuncs.sanitizeHex(
-        ethFuncs.decimalToHex(etherUnits.toWei(txData.value, txData.unit))),
-      data: ethFuncs.sanitizeHex(txData.data)
-    }
-    const eTx = new Tx(rawTx)
-
-    eTx.sign(Buffer.from(txData.key, 'hex'))
-    rawTx.rawTx = JSON.stringify(rawTx)
-    rawTx.signedTx = '0x' + eTx.serialize().toString('hex')
-    rawTx.isError = false
-    return rawTx
-  } catch (e) {
-    return {
-      isError: true,
-      error: e
-    }
+  const rawTx: {[k: string]: any} = {
+    nonce: ethFuncs.sanitizeHex(data.nonce),
+    gasPrice: ethFuncs.sanitizeHex(
+      ethFuncs.addTinyMoreToGas(data.gasprice)),
+    gasLimit: ethFuncs.sanitizeHex(
+      ethFuncs.decimalToHex(txData.gasLimit)),
+    to: ethFuncs.sanitizeHex(txData.to),
+    value: ethFuncs.sanitizeHex(
+      ethFuncs.decimalToHex(etherUnits.toWei(txData.value, txData.unit))),
+    data: ethFuncs.sanitizeHex(txData.data)
   }
+  const eTx = new Tx(rawTx)
+
+  eTx.sign(Buffer.from(txData.key, 'hex'))
+  rawTx.rawTx = JSON.stringify(rawTx)
+  return '0x' + eTx.serialize().toString('hex')
 }
 

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,20 +237,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 +305,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 +334,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 +363,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

@@ -3,7 +3,6 @@ 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 +34,12 @@ 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(data => {
+      if (data.error) {
+        resolve(data)
+      }
+      resolve(data.data)
+    })
     this.pendingPosts.splice(0, 1)
     if (this.pendingPosts.length > 0) { this.queuePost() }
   }
@@ -50,18 +47,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 +63,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 +70,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) {

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'
 
@@ -15,7 +16,8 @@ export default abstract class MessagingWalletAbstract extends Wallet {
 
   public static async createWallet (this: { new(): MessagingWalletAbstract }) {
     const wallet = new this()
-    return wallet.ensureWalletMessageKey()
+    await wallet.ensureWalletMessageKey()
+    return wallet
   }
 
   private publishMessageKey () {
@@ -49,7 +51,7 @@ export default abstract class MessagingWalletAbstract extends Wallet {
     const remoteKey = await this.ajaxReq.getMessageKey(
       this.getAddressString(), true)
     const walletMessageKey = this?.message_key
-    if (remoteKey.public_message_key !== undefined) {
+    if (typeof remoteKey.public_message_key !== 'undefined') {
       this.message_key = {
         pub: remoteKey.public_message_key,
         priv: remoteKey.private_message_key,
@@ -94,7 +96,7 @@ export default abstract class MessagingWalletAbstract extends Wallet {
     const newKey = Wallet.generate(false)
     const mPub = newKey.getPublicKeyString()
     const mPriv = newKey.getPrivateKeyString()
-    return { pub: mPub, priv: cipherMsg(this.getPublicKey(), mPriv) }
+    return { pub: mPub, priv: cipherMsg(this.getPublicKeyString(), mPriv) }
   }
 
   public messageKeysFromCrypted (cipheredKey) {
@@ -120,10 +122,14 @@ export default abstract class MessagingWalletAbstract extends Wallet {
     })
   }
 
-  public enrollAddress (codeId, token) {
-    return this.ajaxReq.enrollAddress(
-      codeId, this.getAddressString(),
-      this.currencyName, token)
+  public enrollAddress (id, token) {
+    return this.ajaxReq.enrollPost({
+      id,
+      token,
+      currency: this.currencyName,
+      // XXXvlab: Yes, typo is intentional here (in PHP API):
+      adresse: this.getAddressString(),
+    })
   }
 
   public requestUnlock () {
@@ -147,54 +153,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)
-//   }
-