@com-chain/jsc3l 2.0.1-rc.0

package/src/rest/serializer.ts

@@ -0,0 +1,99 @@
+
+function isScope (obj) {
+  return obj && obj.$evalAsync && obj.$watch
+}
+
+function isWindow (obj) {
+  return obj && obj.window === obj
+}
+
+function toJsonReplacer (key, value) {
+  let val = value
+  if (typeof key === 'string' &&
+      key.charAt(0) === '$' &&
+      key.charAt(1) === '$') {
+    val = undefined
+  } else if (isWindow(value)) {
+    val = '$WINDOW'
+  } else if (value && window.document === value) {
+    val = '$DOCUMENT'
+  } else if (isScope(value)) {
+    val = '$SCOPE'
+  }
+  return val
+}
+
+function isNumber (arg) {
+  return typeof arg === 'number'
+}
+
+function toJson (obj, pretty?) {
+  if (isUndefined(obj)) { return undefined }
+  if (!isNumber(pretty)) {
+    pretty = pretty ? 2 : null
+  }
+  return JSON.stringify(obj, toJsonReplacer, pretty)
+}
+
+function isDate (value) {
+  return toString.call(value) === '[object Date]'
+}
+
+function isObject (value) {
+  return value !== null && typeof value === 'object'
+}
+
+function serializeValue (v) {
+  if (isObject(v)) {
+    return isDate(v) ? v.toISOString() : toJson(v)
+  }
+  return v
+}
+
+function encodeUriQuery (val, pctEncodeSpaces?) {
+  return encodeURIComponent(val)
+    .replace(/%40/gi, '@')
+    .replace(/%3A/gi, ':')
+    .replace(/%24/g, '$')
+    .replace(/%2C/gi, ',')
+    .replace(/%3B/gi, ';')
+    .replace(/%20/g, pctEncodeSpaces ? '%20' : '+')
+}
+
+function isUndefined (value) {
+  return typeof value === 'undefined'
+}
+
+function forEachSorted (obj, iterator, context?) {
+  const keys = Object.keys(obj).sort()
+  for (let i = 0; i < keys.length; i++) {
+    iterator.call(context, obj[keys[i]], keys[i])
+  }
+  return keys
+}
+
+export default function postSerializer (params) {
+  if (!params) return ''
+
+  const parts = []
+  serialize(params, '', true)
+  return parts.join('&')
+
+  function serialize (toSerialize, prefix, topLevel?) {
+    if (toSerialize === null || isUndefined(toSerialize)) { return }
+    if (Array.isArray(toSerialize)) {
+      toSerialize.forEach(function (value, index) {
+        serialize(value, prefix + '[' + (isObject(value) ? index : '') + ']')
+      })
+    } else if (isObject(toSerialize) && !isDate(toSerialize)) {
+      forEachSorted(toSerialize, function (value, key) {
+        serialize(value,
+          prefix + (topLevel ? '' : '[') + key + (topLevel ? '' : ']'))
+      })
+    } else {
+      parts.push(
+        encodeUriQuery(prefix) + '=' +
+          encodeUriQuery(serializeValue(toSerialize)))
+    }
+  }
+}

package/src/type.ts

@@ -0,0 +1,37 @@
+export const httpMethods = [
+  'GET',
+  'POST',
+  'PUT',
+  'DELETE',
+  'PATCH',
+  'HEAD'
+] as const
+
+export type httpMethod = typeof httpMethods[number]
+
+export type coreHttpOpts = {
+    protocol: string
+    host: string
+    path: string
+    method: httpMethod
+    headers?: {}
+    port?: number
+    data?: any        // TODO: inconsistency with lokapi here
+    timeout?: number
+}
+
+export type HttpRequest = (opts: coreHttpOpts) => Object
+
+export interface IPersistentStore {
+  get(key: string, defaultValue?: string): string
+  set(key: string, value: string): void
+  del(key: string): void
+}
+
+export type UrlParts = {
+    protocol: string
+    host: string
+    port: number
+    path: string
+}
+

package/src/wallet.ts

@@ -0,0 +1,200 @@
+import ethUtil from 'ethereumjs-util'
+
+import AjaxReq from './rest/ajaxReq'
+import { shortenAddress, cipherMsg, decipherMsg } from './ethereum/cipher'
+import Wallet from './ethereum/myetherwallet'
+
+
+export default abstract class MessagingWalletAbstract extends Wallet {
+
+  abstract ajaxReq: AjaxReq  // need to be provided
+  abstract currencyName: string
+  abstract unlockUrl: string
+
+  message_key: null | {pub: string, priv: string} = null
+
+  public static async createWallet (this: { new(): MessagingWalletAbstract }) {
+    const wallet = new this()
+    return wallet.ensureWalletMessageKey()
+  }
+
+  private publishMessageKey () {
+    const dataStr = JSON.stringify({
+      address: this.getAddressString(),
+      public_message_key: this.message_key.pub,
+      private_message_key: this.message_key.priv,
+    })
+
+    return this.ajaxReq.publishMessageKey(dataStr, this.signMessage(dataStr))
+  }
+
+  public async publishReqMessages (addTo, message) {
+    const addFrom = this.getAddressString()
+    const pubKey = async (add) =>
+      (await this.ajaxReq.getMessageKey(add, false)).public_message_key
+
+    const fromMsgKey = await pubKey(addFrom)
+    const toMsgKey = await pubKey(addTo)
+
+    const dataStr = JSON.stringify({
+      add_req: addFrom,
+      add_cli: addTo,
+      ref_req: fromMsgKey ? cipherMsg(fromMsgKey, message) : '',
+      ref_cli: toMsgKey ? cipherMsg(toMsgKey, message) : '',
+    })
+    return this.ajaxReq.publishReqMessages(dataStr, this.signMessage(dataStr))
+  }
+
+  async ensureWalletMessageKey () {
+    const remoteKey = await this.ajaxReq.getMessageKey(
+      this.getAddressString(), true)
+    const walletMessageKey = this?.message_key
+    if (remoteKey.public_message_key !== undefined) {
+      this.message_key = {
+        pub: remoteKey.public_message_key,
+        priv: remoteKey.private_message_key,
+      }
+      if (walletMessageKey?.pub !== remoteKey.public_message_key) {
+        return 'REPLACED_WITH_REMOTE'
+      }
+      return
+    }
+
+    if (!walletMessageKey?.pub || !walletMessageKey?.priv) {
+      this.message_key = this.newMessageKey()
+      this.publishMessageKey()
+      return 'CREATED_NEW'
+    }
+  }
+
+  public async getReqMessage (otherAdd, myMessageKey, didISentThisMsg) {
+    const myAdd = this.getAddressString()
+    const addFrom = didISentThisMsg ? myAdd : otherAdd
+    const addTo = !didISentThisMsg ? myAdd : otherAdd
+    const data = await this.ajaxReq.getReqMessages(addFrom, addTo)
+    if (!data) return ''
+
+    let crypted = ''
+    if (didISentThisMsg && data.ref_from) {
+      crypted = data.ref_from
+    } else if (!didISentThisMsg && data.ref_to) {
+      crypted = data.ref_to
+    } else {
+      return ''
+    }
+
+    try {
+      return decipherMsg(myMessageKey, crypted)
+    } catch (e) {
+      return ''
+    }
+  }
+
+  private newMessageKey () {
+    const newKey = Wallet.generate(false)
+    const mPub = newKey.getPublicKeyString()
+    const mPriv = newKey.getPrivateKeyString()
+    return { pub: mPub, priv: cipherMsg(this.getPublicKey(), mPriv) }
+  }
+
+  public messageKeysFromCrypted (cipheredKey) {
+    // XXXvlab: here we are converting to hex and de-converting in decipherMsg...
+    return shortenAddress(decipherMsg(this.getPrivateKeyString(), cipheredKey))
+  }
+
+  public messageKeysFromWallet () {
+    return this.messageKeysFromCrypted(this.message_key.priv)
+  }
+
+
+  //
+  // Using currencyName
+  //
+
+  public encryptWallet (password) {
+    return this.toV3(password, {
+      kdf: 'scrypt',
+      n: 1024,
+      server_name: this.currencyName,
+      message_key: this.message_key
+    })
+  }
+
+  public enrollAddress (codeId, token) {
+    return this.ajaxReq.enrollAddress(
+      codeId, this.getAddressString(),
+      this.currencyName, token)
+  }
+
+  public requestUnlock () {
+    return this.ajaxReq.requestUnlock(
+      this.getAddressString(),
+      this.unlockUrl)
+  }
+
+  public static getWalletFromPrivKeyFile (jsonStr, password) {
+    const jsonArr = JSON.parse(jsonStr)
+    if (jsonArr.encseed != null) return this.fromEthSale(jsonStr, password)
+    else if (jsonArr.Crypto != null ||
+      jsonArr.crypto != null) {
+      return this.fromV3(jsonStr, password, true)
+    } else if (jsonArr.hash != null) {
+      return this.fromMyEtherWallet(jsonStr, password)
+    } else if (jsonArr.publisher === 'MyEtherWallet') {
+      return this.fromMyEtherWalletV2(jsonStr)
+    } else {
+      throw new Error("Sorry! We don't recognize this type of wallet file.")
+    }
+  }
+
+
+  //
+  // QR Codes requires EthUtils
+  //
+
+  public makeSignedQRWithPubKey (objContent, pubKey) {
+    objContent.message_key = cipherMsg(
+      pubKey, this.messageKeysFromWallet()
+    )
+    objContent.address = this.getAddressString()
+    return this.makeSignedQR(objContent)
+  }
+
+  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)
+    })
+
+    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')
+        }
+      })
+    }
+  }
+
+}
+
+// // TODO: What to do with this validateEnrollment
+// public static validateEnrollment (codeId, signature) {
+//     return this.ajaxReq.validateEnrollmentLetter(
+//       codeId, this.currencyName, signature)
+//   }
+

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+        "target": "es2017",
+        "module": "esnext",
+        "moduleResolution": "node",
+        "declaration": true,
+        "removeComments": false,
+        "emitDecoratorMetadata": true,
+        "experimentalDecorators": true,
+        "sourceMap": true,
+        "skipLibCheck": true,
+        "allowUnreachableCode": false,
+        "allowUnusedLabels": false,
+        "noEmitHelpers": true,
+        "noEmitOnError": false,
+        "noImplicitAny": false,
+        "noImplicitReturns": false,
+        "noImplicitUseStrict": false,
+        "noFallthroughCasesInSwitch": true,
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true,
+        "lib": ["esnext", "dom"],
+        "baseUrl": ".",
+        "outDir": "build",
+        "paths": {
+            "*": ["src/types/*"]
+        }
+    },
+    "include": ["src/**/*", "references.d.ts"],
+    "exclude": ["node_modules", "platforms", "**/angular"]
+}