@com-chain/jsc3l 2.0.1-rc.0

package/src/bcTransaction.ts

@@ -0,0 +1,157 @@
+
+import { getNakedAddress, padLeft, encodeNumber } from './ethereum/ethFuncs'
+import { generateTx } from './ethereum/uiFuncs'
+import AjaxReq from './rest/ajaxReq'
+
+
+function roundCent (strAmount:string) {
+  return Math.round(100 * parseFloat(strAmount))
+}
+
+
+function typeConv (label: string): (x:any) => (string | number) {
+  if (label.endsWith('Address')) {
+    return (a) => padLeft(getNakedAddress(a), 64)
+  }
+  if (label.startsWith('limit') || label === 'amount') {
+    return (nb) => encodeNumber(roundCent(nb))
+  }
+  if (label.endsWith('Status') || label.endsWith('Type')) {
+    return (nb) => encodeNumber(nb)
+  }
+  if (label === 'status') {
+    return (nb) => (parseInt(nb, 10) === 0 ? 0 : 1)
+  }
+  throw new Error(`Unexpected label '${label}' in FnDefs.`)
+}
+
+
+export default abstract class BcTransactionAbstract {
+
+  abstract ajaxReq: AjaxReq
+  abstract contracts: string[]
+
+  // //////////////////////////////////////////////////////////////////////////
+  //  CM VS Nant Handling
+
+  getSplitting (nantVal, cmVal, cmMinusLim, amount) {
+    cmVal = parseFloat(cmVal)
+    nantVal = parseFloat(nantVal)
+    let nant = 0
+    let cm = 0
+
+    let res = parseFloat(amount)
+    if (cmVal > 0) {
+      if (cmVal >= res) {
+        cm = res
+        res = 0
+      } else {
+        cm = cmVal
+        res = res - cmVal
+        cmVal = 0
+      }
+    }
+
+    if (nantVal > 0) {
+      if (nantVal >= res) {
+        nant = res
+        res = 0
+      } else {
+        nant = nantVal
+        res = res - nantVal
+        // nantVal=0;
+      }
+    }
+
+    if (res > 0 && cmVal - parseFloat(cmMinusLim) >= res) {
+      cm = cm + res
+      res = 0
+    }
+
+    const possible = res === 0
+    return { possible: possible, nant: nant, cm: cm }
+  }
+
+  // //////////////////////////////////////////////////////////////////////////
+
+}
+
+
+[
+  // First Contract
+  {
+    setAccountParam: '848b2592:accAddress accStatus accType limitPlus limitMinus',
+    pledgeAccount: '6c343eef:accAddress amount *',
+    setAllowance: 'd4e12f2e:spenderAddress amount',
+    setDelegation: '75741c79:spenderAddress limit',
+    setTaxAmount: 'f6f1897d:amount',
+    setTaxLegAmount: 'fafaf4c0:amount',
+    setTaxAccount: 'd0385b5e:accAddress',
+    setOwnerAccount: 'f2fde38b:accAddress',
+    setContractStatus: '0x88b8084f:status',
+  },
+  // Second Contract
+  {
+    transferNant: 'a5f7c148:toAddress amount *',
+    transferCM: '60ca9c4c:toAddress amount *',
+    transferOnBehalfNant: '1b6b1ee5:fromAddress toAddress amount D',
+    transferOnBehalfCM: '74c421fe:fromAddress toAddress amount D',
+    askTransferFrom: '58258353:fromAddress amount',
+    askTransferCMFrom: '2ef9ade2:fromAddress amount',
+    payRequestNant: '132019f4:toAddress amount *',
+    payRequestCM: '1415707c:toAddress amount *',
+    rejectRequest: 'af98f757:toAddress',
+    dismissAcceptedInfo: 'ccf93c7a:accAddress',
+    dismissRejectedInfo: '88759215:accAddress',
+  }
+].forEach((contractFnDefs, contractNb) => {
+
+  for (const fnName in contractFnDefs) {
+
+    const [fnHash, argStringList] = contractFnDefs[fnName].split(':')
+    const argList = argStringList.split(' ')
+    let hasAdditionalPostData = false
+    let hasDelegate = false
+    if (argList.slice(-1)[0] === '*') {
+      hasAdditionalPostData = true
+      argList.pop()
+    } else if (argList.slice(-1)[0] === 'D') {
+      hasAdditionalPostData = true
+      hasDelegate = true
+      argList.pop()
+    }
+
+    // Build argument array function
+    const argFnList = argList.map((arg) => typeConv(arg))
+    const concatArgs = (args) =>
+      args.map((arg, idx) => argFnList[idx](arg)).join('')
+
+    BcTransactionAbstract.prototype[fnName] = async function (wallet, ...args) {
+      const addr = wallet.getAddressString()
+      const data = await this.ajaxReq.getTransactionData(addr)
+      // TODO: must test this
+      if (data.error) {
+        console.log(`Failed getTransactionData(${addr})`)
+        throw new Error(data.msg)
+      }
+      const additionalPostData = hasAdditionalPostData ? args.pop() : {}
+      if (hasDelegate) {
+        additionalPostData.delegate = wallet.getAddressString()
+      }
+      const rawTx = generateTx({
+        gasLimit: 500000,
+        data: fnHash + concatArgs(args),
+        to: this.contracts[contractNb],
+        unit: 'ether',
+        value: 0,
+        nonce: 1,
+        gasPrice: null,
+        donate: false,
+        from: addr,
+        key: wallet.getPrivateKeyString()
+      }, data)
+      if (rawTx.isError) return rawTx
+      return this.ajaxReq.sendTx(rawTx.signedTx, additionalPostData)
+    }
+  }
+})

package/src/blockies.ts

@@ -0,0 +1,113 @@
+
+// Adapted from
+// https://github.com/alexvandesande/blockies/blob/master/blockies.js
+// updated tayvano 3.9.16
+
+// The random number is a js implementation of the Xorshift PRNG
+const randseed = new Array(4) // Xorshift: [x, y, z, w] 32 bit values
+
+function seedrand (seed) {
+  for (let i = 0; i < randseed.length; i++) {
+    randseed[i] = 0
+  }
+  for (let i = 0; i < seed.length; i++) {
+    randseed[i % 4] = ((randseed[i % 4] << 5) - randseed[i % 4]) +
+      seed.charCodeAt(i)
+  }
+}
+
+function rand () {
+  // based on Java's String.hashCode(), expanded to 4 32bit values
+  const t = randseed[0] ^ (randseed[0] << 11)
+
+  randseed[0] = randseed[1]
+  randseed[1] = randseed[2]
+  randseed[2] = randseed[3]
+  randseed[3] = (randseed[3] ^ (randseed[3] >> 19) ^ t ^ (t >> 8))
+
+  return (randseed[3] >>> 0) / ((1 << 31) >>> 0)
+}
+
+function createColor () {
+  // saturation is the whole color spectrum
+  const h = Math.floor(rand() * 360)
+  // saturation goes from 40 to 100, it avoids greyish colors
+  const s = ((rand() * 60) + 40) + '%'
+  // lightness can be anything from 0 to 100, but probabilities are a
+  // bell curve around 50%
+  const l = ((rand() + rand() + rand() + rand()) * 25) + '%'
+
+  const color = 'hsl(' + h + ',' + s + ',' + l + ')'
+  return color
+}
+
+function createImageData (size) {
+  const width = size // Only support square icons for now
+  const height = size
+
+  const dataWidth = Math.ceil(width / 2)
+  const mirrorWidth = width - dataWidth
+
+  const data = []
+  for (let y = 0; y < height; y++) {
+    let row = []
+    for (let x = 0; x < dataWidth; x++) {
+      // this makes foreground and background color to have a 43%
+      // (1/2.3) probability spot color has 13% chance
+      row[x] = Math.floor(rand() * 2.3)
+    }
+    const r = row.slice(0, mirrorWidth)
+    r.reverse()
+    row = row.concat(r)
+
+    for (let i = 0; i < row.length; i++) {
+      data.push(row[i])
+    }
+  }
+
+  return data
+}
+
+function createCanvas (imageData, color, scale, bgcolor, spotcolor) {
+  const c = document.createElement('canvas')
+  const width = Math.sqrt(imageData.length)
+  c.width = c.height = width * scale
+
+  const cc = c.getContext('2d')
+  cc.fillStyle = bgcolor
+  cc.fillRect(0, 0, c.width, c.height)
+  cc.fillStyle = color
+
+  for (let i = 0; i < imageData.length; i++) {
+    const row = Math.floor(i / width)
+    const col = i % width
+    // if data is 2, choose spot color, if 1 choose foreground
+    cc.fillStyle = (imageData[i] === 1) ? color : spotcolor
+
+    // if data is 0, leave the background
+    if (imageData[i]) {
+      cc.fillRect(col * scale, row * scale, scale, scale)
+    }
+  }
+
+  return c
+}
+
+export default function (opts) {
+  opts = opts || {}
+  const size = opts.size || 8
+  const scale = opts.scale || 4
+  const seed = opts.seed || Math.floor((Math.random() *
+    Math.pow(10, 16))).toString(16)
+
+  seedrand(seed)
+
+  const color = opts.color || createColor()
+  const bgcolor = opts.bgcolor || createColor()
+  const spotcolor = opts.spotcolor || createColor()
+  const imageData = createImageData(size)
+  const canvas = createCanvas(imageData, color, scale, bgcolor, spotcolor)
+
+  return canvas
+}
+

package/src/config.ts

@@ -0,0 +1,33 @@
+
+export const confEndPointsOur = [
+  'https://node-001.cchosting.org',
+  'https://node-002.cchosting.org',
+  'https://node-003.cchosting.org',
+  'https://node-004.cchosting.org',
+  'https://node-cc-001.cchosting.org/',
+  'https://api.monnaie-leman.org'
+]
+
+export const confEndPointsOther = [
+  'https://ipfs.io',
+  'https://ipfs.infura.io',
+  'https://ipfs.jes.xxx',
+  'https://siderus.io',
+  'https://hardbin.com',
+  'https://ipfs.infura.io',
+  'https://xmine128.tk'
+]
+
+// IPNS of the list of available ComChain currency configs
+export const configRepo =
+  '/ipns/QmaAAZor2uLKnrzGCwyXTSwogJqmPjJgvpYgpmtz5XcSmR/configs'
+
+// IPNS of the list of available ComChain end-points
+export const nodesRepo =
+  '/ipns/QmcRWARTpuEf9E87cdA4FfjBkv7rKTJyfvsLFTzXsGATbL'
+
+// IPNS of the configuration for the different currencies
+export const custoRepo =
+  '/ipns/QmaAAZor2uLKnrzGCwyXTSwogJqmPjJgvpYgpmtz5XcSmR/resources/'
+
+export const ping = configRepo + '/ping.json'

package/src/connection.ts

@@ -0,0 +1,243 @@
+import * as config from './config'
+import HttpAbstract from './rest/http'
+import * as t from './type'
+
+
+abstract class ConnectionAbstract {
+
+  protected abstract http: HttpAbstract
+
+
+  ///
+  // [High level] Look for an available IPFS/IPNS node and return it
+  ///
+
+  public async lookupAvailableComChainRepo (storedEndPointsSuggestion?: string[]) {
+    // 1. Check if a list of endpoint is stored locally (avoid a IPNS slow call)
+    const storedEndPoints = storedEndPointsSuggestion || []
+
+    const endPointLists = [
+      storedEndPoints, // 1. try locally stored end-points if any
+      config.confEndPointsOur, // 2. try the hard-coded Com-Chain list
+      config.confEndPointsOther // 3. As a backup try standard ipfs servers (slow)
+    ]
+
+    for (let i = 0; i < endPointLists.length; i++) {
+      const repo = await this.checkRepo(endPointLists[i])
+      if (repo) return repo
+    }
+    return false
+  }
+
+  ///
+  // [High level] Get the list of endpoints and randomly select a up
+  // and running one
+  ///
+  public async acquireEndPoint (repo: string) {
+    const apiNodes = await this.getCCEndPointList(repo)
+    if (!apiNodes) return false
+    const endpoint = await this.selectEndPoint(apiNodes)
+    return { apiNodes, endpoint }
+  }
+
+  ///
+  // [Lower level] Get the list of ComChain end-points from given repo
+  ///
+  getCCEndPointList (repo: string) {
+    return this.http.get(repo + config.nodesRepo, { _: new Date().getTime() })
+  }
+
+  ///
+  // [Lower level] Select a ComChain end-point with up and running APIs
+  ///
+  async selectEndPoint (nodes: string[]) {
+    while (nodes.length > 0) {
+      // randomly select a node (poor man's load balancing)
+      const id = Math.floor((Math.random() * nodes.length))
+      const node = nodes[id]
+
+      // check the node is up and running
+      const success = await this.testNode(node)
+      if (success) return node
+      nodes.splice(id, 1)
+    }
+    return false
+  }
+
+  ///
+  // [Lower level] Test if a end-point has up and running APIs
+  ///
+  async testNode (apiAddress) {
+    const result = await this.testDbApi(apiAddress)
+    if (!result) return false
+
+    return this.testApi(apiAddress)
+  }
+
+
+  // //////////////////////////////////////////////////////////////////////////
+
+  async checkRepo (repoList) {
+    while (repoList?.length) {
+      const id = Math.floor((Math.random() * repoList.length))
+      const repo = repoList[id]
+      try {
+        await this.http.get(repo + config.ping, null, { timeout: 3000 })
+        console.log(`Connection OK to ${repo}`)
+        return repo
+      } catch (err) {
+        console.log(`Failed to make contact ${repo} in less that 3s`)
+        console.log(`  Reason: ${err}`)
+        repoList.splice(id, 1)
+      }
+    }
+    return false
+  }
+
+  async testApi (apiAddress) {
+    try {
+      const answer = await this.http.get(
+        apiAddress + '/api.php', null,
+        { timeout: 5000 })
+      return answer !== 'null' && !answer.error && answer
+    } catch (err) {
+      console.log(`API Check: HTTP request to ${apiAddress} failed`, err)
+      return false
+    }
+  }
+
+  async testDbApi (apiAddress) {
+    try {
+      const answer = await this.http.get(
+        apiAddress + '/dbcheck.php', null,
+        { timeout: 5000 })
+      return answer === 'pong'
+    } catch (err) {
+      console.log(`DbAPI Check: HTTP request to ${apiAddress} failed`, err)
+      return false
+    }
+  }
+
+
+  /**
+   * Gets the configuration for the given currency
+   *
+   */
+  public async getConfJSON (repo, currencyName) {
+    try {
+      return await this.http.get(
+        `${repo}${config.configRepo}/${currencyName}.json`,
+        { _: new Date().getTime() })
+    } catch (err) {
+      return false
+    }
+  }
+
+}
+
+
+/**
+ * Manages Persistent Store to keep list of nodes and avoid IPFS lookup
+ * when possible.
+ *
+ */
+export default abstract class ConnectionMgrAbstract extends ConnectionAbstract {
+
+  protected abstract persistentStore: t.IPersistentStore
+
+  repo: string
+  conf: any
+  endpoint: string
+
+
+  /**
+   * This lookup will store result in memory for speeding other methods.
+   */
+  public async lookupAvailableComChainRepo (storedEndPointsSuggestion?: string[]) {
+
+    if (!storedEndPointsSuggestion) {
+      const apiNodeSuggestions = this.persistentStore.get('ApiNodes', '[]')
+      storedEndPointsSuggestion = JSON.parse(apiNodeSuggestions)
+    }
+    const repo = await super.lookupAvailableComChainRepo(storedEndPointsSuggestion)
+    if (!repo) {
+      throw new Error('No repository available.')
+    }
+    this.repo = repo
+    return repo
+  }
+
+
+  /**
+   * This lookup will store result in memory for speeding other methods.
+   * and saves the result in persistentStore for faster calls.
+   */
+  public async acquireEndPoint (repo?: string) {
+    if (!repo) {
+      if (!this.repo) {
+        // Will have a look in the persistent store for suggestions,
+        // and save in `this.repo` the result for other methods.
+        await this.lookupAvailableComChainRepo()
+      }
+      repo = this.repo
+    }
+    const apiNodesEndpoint = await super.acquireEndPoint(repo)
+    if (!apiNodesEndpoint) {
+      throw new Error('Endpoint list retrieval failed.')
+    }
+    const { apiNodes, endpoint } = apiNodesEndpoint
+    if (typeof endpoint !== 'string') {
+      throw new Error('No endpoint in list seems available.')
+    }
+
+    this.persistentStore.set('ApiNodes', JSON.stringify(apiNodes))
+    this.endpoint = endpoint
+    return { apiNodes, endpoint }
+  }
+
+
+  /**
+   * This lookup will store result in memory for speeding other methods.
+   * and saves the result in persistentStore for faster calls.
+   * - If argument `repo` is not provided, it'll use the last one in memory
+   * leaved by a previous call of `lookupAvailableComChainRepo()`.
+   * - If no previous call was made, it'll do one.
+   */
+  public async getConfJSON (currencyName: string, repo?: string) {
+    if (!repo) {
+      if (!this.repo) {
+        // Will have a look in the persistent store for suggestions,
+        // and save in `this.repo` the result for other methods.
+        await this.lookupAvailableComChainRepo()
+      }
+      repo = this.repo
+    }
+    const conf = await super.getConfJSON(repo, currencyName)
+    if (!conf) {
+      throw new Error('Failed to get conf.')
+    }
+    this.persistentStore.set('ServerConf', JSON.stringify(conf))
+    this.conf = conf
+    // Completing with other informations
+    conf.repo = repo
+    conf.custoRepo = repo + config.custoRepo
+    return conf
+  }
+
+
+  /**
+   * Return conf stored in memory or persistent storage (need to
+   * be not async).
+   */
+  public getLocalConfJSON () {
+    if (this.conf) return this.conf
+    const cfgJson = this.persistentStore.get('ServerConf')
+    if (!cfgJson) return null
+    const cfg = JSON.parse(cfgJson)
+    // Completing with other informations
+    cfg.repo = this.repo
+    cfg.custoRepo = this.repo + config.custoRepo
+    return cfg
+  }
+
+}

package/src/customization.ts

@@ -0,0 +1,156 @@
+
+export default abstract class CustomizationAbstract {
+
+  abstract cfg: any
+  localDefaultConf: any
+
+  /**
+   * Pre-requisite: the variable confLocale should store an object with
+   * at least the following infos:
+   *   localDefaultConf.server.lang
+   *   localDefaultConf.server.notes
+   *   localDefaultConf.server.url_Css
+   */
+  constructor (localDefaultConf) {
+    this.localDefaultConf = localDefaultConf
+  }
+
+  // [High level] Get the individual configuration
+  ///
+
+  public getCurrencyName () {
+    return this.getServerConfig('name')
+  }
+
+  public getContract1 () {
+    return this.getServerConfig('contract_1')
+  }
+
+  public getContract2 () {
+    return this.getServerConfig('contract_2')
+  }
+
+  public getContract3 () {
+    return this.getServerConfig('contract_3')
+  }
+
+  public getHelpUrl () {
+    return this.getServerConfig('url_help')
+  }
+
+  public getCondUrl () {
+    return this.getServerConfig('url_cond')
+  }
+
+  public getUnlockUrl () {
+    return this.getServerConfig('url_unlock')
+  }
+
+  public getHowToUrl () {
+    return this.getServerConfig('url_howto')
+  }
+
+  public getWalletAddress () {
+    return this.getServerConfig('address')
+  }
+
+  public getCreationMessage () {
+    return this.getServerConfig('creat_message')
+  }
+
+  public getLang () {
+    return this.getServerConfig('lang') || this.localDefaultConf.server?.lang
+  }
+
+  public getNoteValues () {
+    return this.getServerConfig('notes') || this.localDefaultConf.server?.notes
+  }
+
+  public hasBn () {
+    return !!this.getNoteValues()
+  }
+
+  public hasNant () {
+    return this.getServerConfigSwitch('nant', false)
+  }
+
+  public hasCM () {
+    return this.getServerConfigSwitch('CM', false)
+  }
+
+  public hasAutor () {
+    return this.getServerConfigSwitch('autor', false)
+  }
+
+  public hasDeleg () {
+    return this.getServerConfigSwitch('deleg', false)
+  }
+
+  public hasPayRequest () {
+    return this.getServerConfigSwitch('payReq', false)
+  }
+
+  public passwordAutocomplete () {
+    let number = 10000
+    try {
+      if (this.cfg.server.passwordAutocomplete &&
+          this.cfg.server.passwordAutocomplete > 0) {
+        number = this.cfg.server.passwordAutocomplete
+      }
+    } catch (e) {
+
+    }
+    return number
+  }
+
+  public getCurrencies () {
+    return this.getServerConfig('currencies')
+  }
+
+  // ///////////////////////////////////////////////////////////////////////////
+
+  public getServerConfig (configName) {
+    try {
+      return this.cfg.server[configName]
+    } catch (e) {
+      return ''
+    }
+  }
+
+  public getServerConfigSwitch (configName, defaultValue) {
+    try {
+      return this.cfg.server[configName].toString().toLowerCase() === 'true'
+    } catch (e) {
+      return defaultValue
+    }
+  }
+
+  // ///////////////////////////////////////////////////////////////////////////
+
+  public getCurrencyAssetBaseUrl (currencyName?: string) {
+    if (!currencyName) {
+      currencyName = this.cfg.server.name
+    }
+    return `${this.cfg.custoRepo}${currencyName}`
+  }
+
+  public getCssUrl (currencyName?: string) {
+    try {
+      // XXXvlab: I guess that we don't need to keep 'etherwallet' css names
+      return `${this.getCurrencyAssetBaseUrl(currencyName)}/css/etherwallet-master.min.css`
+    } catch (e) {
+      return this.localDefaultConf.server.url_Css
+    }
+  }
+
+  public getCurrencyLogoUrl (currencyName?: string) {
+    try {
+      // XXXvlab: I guess that 'lem' stands for leman here. Shouldn't that
+      // be agnostic ?
+      return `${this.getCurrencyAssetBaseUrl(currencyName)}/images/lem.png`
+    } catch (e) {
+      return ''
+    }
+  }
+
+}