zetrix-connect-wallet-sdk-test 1.0.0

package/lib/qrcode.js

@@ -0,0 +1,75 @@
+import {qrcanvas} from 'qrcanvas'
+import {resultInfo} from './result'
+
+
+export const appendCode = (data, callBack) => {
+    const code = createQrcode(data)
+    let hasDom = document.getElementById('zetrixWalletConnectQr')
+    if (hasDom) {
+        document.body.removeChild(hasDom)
+    }
+    let divDom = document.createElement("div");
+    divDom.className = 'zetrix_wallet_connect_wrapper'
+    divDom.setAttribute('id', 'zetrixWalletConnectQr')
+    divDom.innerHTML = "<div class='zetrix_wallet_connect_box'>" +
+        "<h2>Scan with the Zetrix Wallet app</h2>" +
+        "<img src='"+code+"' width='100%' />" +
+        "</div>"
+    let bodyDom = document.body
+    bodyDom.insertBefore(divDom, bodyDom.lastChild);
+
+    divDom.onclick = function(){
+        let hasDom = document.getElementById('zetrixWalletConnectQr')
+        document.body.removeChild(hasDom)
+        if (callBack) {
+            callBack(resultInfo.closeNotice)
+        }
+    }
+}
+
+export const loadQrCss = () => {
+    let style = document.createElement('style');
+    style.type = 'text/css';
+    style.innerHTML=".zetrix_wallet_connect_wrapper{\n" +
+        "    width: 100%;\n" +
+        "    height:100%;\n" +
+        "    background: rgba(0,0,0,.8);\n" +
+        "    position: fixed;\n" +
+        "    left:0;\n" +
+        "    top:0;\n" +
+        "    z-index: 9999999999;\n" +
+        "    user-select: none;\n" +
+        "    transition: .2s ease-in-out;\n" +
+        "}\n" +
+        ".zetrix_wallet_connect_box{\n" +
+        "    width: 400px;\n" +
+        "    padding: 20px;\n" +
+        "    border-radius: 20px;\n" +
+        "    background-color: #FFF;\n" +
+        "    position: absolute;\n" +
+        "    left: 50%;\n" +
+        "    top:50%;\n" +
+        "    transform: translate(-50%, -50%);\n" +
+        "}\n" +
+        ".zetrix_wallet_connect_box h2 {\n" +
+        "    font-size: 18px;\n" +
+        "    text-align: center;\n" +
+        "     margin: 0 0 15px 0;\n" +
+        "    color:#999;\n" +
+        "}";
+    document.getElementsByTagName('HEAD').item(0).appendChild(style);
+}
+
+export const closeQr = () => {
+    let hasDom = document.getElementById('zetrixWalletConnectQr')
+    if (hasDom) {
+        document.body.removeChild(hasDom)
+    }
+}
+
+const createQrcode = (data) => {
+    const canvas = qrcanvas({
+        data: data
+    })
+    return canvas.toDataURL("image/png")
+}

package/lib/result.js

@@ -0,0 +1,59 @@
+export const resultInfo = {
+    noUseSocket: {
+        code: 90001,
+        message: 'Your browser does not support the Websocket communication protocol'
+    },
+    noUseLocalStorage: {
+        code: 90002,
+        message: 'Your browser does not support window.localStorage'
+    },
+    nonceNotActivated: {
+        code: 10010,
+        message: 'Account not activated'
+    },
+    nonceNotAuth: {
+        code: 10011,
+        message: 'Unexecuted authorization'
+    },
+    closeNotice: {
+        code: 1,
+        message: 'Cancelled'
+    },
+    h5ParametersMastObject: {
+        code: 2000,
+        message: 'Parameter format error, parameter format is object'
+    },
+    h5RequiredParametersError: {
+        code: 2001,
+        message: 'Missing required parameters'
+    },
+}
+
+export const typeInfo = {
+    storageName: 'zetrixWalletConnect',
+    mobileSource: 'mobile'
+}
+
+export const hostParam = {
+    android: 'zetrixnew://zetrix.com/app/flutter',
+    ios: 'zetrixnew://zetrix.com/app/flutter',
+    androidpixa: 'pixa://pixa.com/app/flutter',
+    iospixa: 'pixa://pixa.com/app/flutter'
+}
+
+export const sdkType = {
+    bind: 'bind',
+    auth: 'auth',
+    signMessage: 'signMessage',
+    signBlob: 'signBlob',
+    sendTransaction: 'sendTransaction',
+    setQr: 'put',
+    bindAndSignMessage: 'bindAndSignMessage'
+}
+
+export const errorCode = -1
+
+export const systemErrorInfo = {
+    abnormalOperation: 'Abnormal operation',
+    iosSupportError: 'Sorry, IOS is not currently supported'
+}

package/lib/socket.js

@@ -0,0 +1,139 @@
+'use strict'
+import {compatibleSocket, compatibleStorage, getAddress, getSessionId} from './util'
+import {sdkType} from './result'
+class WalletSocket {
+    constructor (url) {
+        this.url = url
+        this._websocket = null
+
+        this.closeConfig = {
+            resolve: null,
+            closing: false
+        }
+
+        this.promisePool = {}
+    }
+    connect () {
+        return new Promise((resolve, reject) => {
+
+            let socketResult = compatibleSocket()
+            if (socketResult.code !== 0) {
+                reject(socketResult)
+            }
+
+            let locResult = compatibleStorage()
+            if (locResult.code !== 0) {
+                reject(locResult)
+            }
+
+
+            if (typeof(WebSocket) == "function") {
+                this._websocket = new WebSocket(this.url)
+                this._websocket.onopen = () => {
+                    console.log('ws open successfully')
+                    this.closeConfig.closing = false
+
+                    let authResult = this.callbackAuthInfo()
+                    resolve(authResult)
+
+                    this.afterOpenToBind()
+                }
+                this._websocket.onerror = (e) => {
+                    reject(e)
+                }
+                this._websocket.onclose = () => {
+                    console.warn('Websocket closed')
+                    if (!this.closeConfig.closing) {
+                        console.warn('Websocket reconnect')
+                        this.connect().then()
+                    }
+
+                }
+                this._websocket.onmessage = (evt) => {
+
+                    try {
+                        let resp = JSON.parse(evt.data)
+                        if (!resp.type) {
+                            return false
+                        }
+
+                        let type = resp.type.split('_')[1]
+                        if (type === 'auth') {
+                            type = 'bind'
+                        }
+                        type = 'H5_' + type
+
+                        let req = this.promisePool[type]
+
+                        if (!req) {
+                            return
+                        }
+
+                        req.resolve(resp)
+
+                    } catch (e) {
+                        console.error(e)
+                    }
+                }
+            }
+
+        })
+    }
+    // changeCallBackData (resp) {
+    //     if (resp.data.isAuth === 1) {
+    //         resp.type = 'H5_' + sdkType.bind
+    //         return resp
+    //     } else {
+    //         return resp
+    //     }
+    // }
+    send (method, data) {
+        return new Promise((resolve, reject) => {
+            this.promisePool[method] = {
+                resolve,
+                reject
+            }
+            data.type = method
+            let req = JSON.stringify(data)
+            this._websocket.send(req)
+        })
+    }
+
+
+
+    disconnect () {
+        this.closeConfig.closing = true
+        this._websocket.close()
+    }
+    h5Bind (data) {
+        return this.send('H5_'+ sdkType.bind, data)
+    }
+    afterOpenToBind () {
+        if (getSessionId()) {
+            let sendBind = {
+                type: 'H5_bind',
+                sessionId: getSessionId()
+            }
+            this._websocket.send(JSON.stringify(sendBind))
+        }
+    }
+    callbackAuthInfo () {
+        let addressStr = getAddress()
+        let sessionIdStr = getSessionId()
+        if (addressStr && sessionIdStr){
+            return {
+                code: 0,
+                data: {
+                    address: addressStr
+                }
+            }
+        } else {
+            return {
+                code: 0,
+                data: {}
+            }
+        }
+    }
+}
+
+export default WalletSocket

package/lib/util.js

@@ -0,0 +1,221 @@
+import {resultInfo, typeInfo} from './result'
+import MobileDetect from './mobileDetect'
+
+export const createSessionId = () => {
+    let s = [];
+    let hexDigits = "0123456789abcdef";
+    for (let i = 0; i < 36; i++) {
+        s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
+    }
+    s[14] = "4";
+    s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1);
+    s[8] = s[13] = s[18] = s[23] = "-";
+
+    let uuid = s.join("");
+    return uuid;
+}
+
+export const compatibleSocket = () => {
+    if( typeof(WebSocket) != "function" ) {
+        console.error(resultInfo.noUseSocket.message)
+        return {
+          code: resultInfo.noUseSocket.code,
+          message: resultInfo.noUseSocket.message
+        }
+    } else {
+      return {
+        code: 0
+      }
+    }
+}
+
+export const compatibleStorage = () => {
+    if(typeof window.localStorage == 'undefined') {
+        console.error(resultInfo.noUseLocalStorage.message)
+        return {
+            code: resultInfo.noUseLocalStorage.code,
+            message: resultInfo.noUseLocalStorage.message
+        }
+    } else {
+        return {
+            code: 0
+        }
+    }
+}
+
+export const getWindowUrl = () => {
+    return  window.location.protocol + '//' + window.location.host
+}
+
+export const getWindowICO = () => {
+    let ico = ''
+    try {
+        ico = document.querySelectorAll("link[rel*='icon']")[0].href || ''
+    } catch (e) {
+        ico = ''
+    }
+    return ico
+}
+
+export const useDevice = () => {
+    let u = navigator.userAgent;
+    let isiOS = !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/);
+    let isAndroid = u.indexOf('Android') > -1 || u.indexOf('Adr') > -1;
+
+    if(isAndroid) {
+       return 'android'
+    } else if(isiOS) {
+       return 'ios'
+    }
+}
+
+export const useClientName = () => {
+    const md = new MobileDetect(window.navigator.userAgent);
+    const client = md.userAgent()
+    return client || ''
+}
+
+export const warnIncorrectLog = (name) => {
+    return `The '${name}' argument is incorrect`
+}
+
+export const getSessionId = () => {
+    let storageData = window.localStorage.getItem(typeInfo.storageName)
+    if (!storageData) {
+        return false
+    }
+    storageData = JSON.parse(storageData)
+    if (storageData.sessionId) {
+        return storageData.sessionId
+    } else {
+        return false
+    }
+}
+
+export const getAddress = () => {
+    let storageData = window.localStorage.getItem(typeInfo.storageName)
+    if (!storageData) {
+        return false
+    }
+    storageData = JSON.parse(storageData)
+    if (storageData.address) {
+        return storageData.address
+    } else {
+        return false
+    }
+}
+
+export const setAuthData = (sessionId, address) => {
+    let storageData = window.localStorage.getItem(typeInfo.storageName)
+    if (!storageData) {
+        let setData = { sessionId: sessionId, address: address }
+        window.localStorage.setItem(typeInfo.storageName, JSON.stringify(setData))
+    } else {
+        storageData = JSON.parse(storageData)
+        storageData.sessionId = sessionId
+        storageData.address = address
+        window.localStorage.setItem(typeInfo.storageName, JSON.stringify(storageData))
+    }
+}
+
+export const disconnectRemoveStorage = () => {
+    window.localStorage.removeItem(typeInfo.storageName)
+}
+
+export const isMobile = () => {
+    if ('ontouchstart' in window) {
+        return true
+    } else {
+        return  false
+    }
+}
+
+export const setLocalStorage = (name, value) => {
+    window.localStorage.setItem(name, value)
+}
+
+export const getLocalStorage = (name) => {
+    let data = window.localStorage.getItem(name)
+    if (!data) {
+        return ''
+    }
+    return data
+}
+
+export const isJSON = (str) =>  {
+    if (typeof str == 'string') {
+        try {
+            var obj=JSON.parse(str);
+            if(typeof obj == 'object' && obj ){
+                return true;
+            }else{
+                return false;
+            }
+        } catch(e) {
+            console.log('error：'+str+'!!!'+e);
+            return false;
+        }
+    }
+}
+
+export const openInWebview = () => {
+    var useragent = navigator.userAgent;
+    var rules = ['WebView','(iPhone|iPod|iPad)(?!.*Safari/)','Android.*(wv|.0.0.0)'];
+    var regex = new RegExp(`(${rules.join('|')})`, 'ig');
+    return Boolean(useragent.match(regex));
+}
+
+
+export const fixedRequestParameters  = (oParams={}) => {
+    let mustParameters = {
+        data: {
+          source: {
+           isBackData: true,
+           sourceType: 'triggerApp'
+          },
+          payload: {
+            ...oParams
+          }
+        }
+      }
+    return JSON.stringify(mustParameters)
+}
+
+export const resReturnedData = (res) => {
+    let parseRes = res
+    console.log(parseRes, 'parseRes1');
+    let oParams = {
+        code: parseRes.code,
+        data: parseRes.data.payload,
+        message: parseRes.message
+    }
+    if (parseRes.data.source.chainId) {
+        oParams.data.chainId = parseRes.data.source.chainId
+    }
+    return oParams
+}
+
+export const isAnObject = (obj) => {
+    if (obj instanceof Object) {
+        return true
+    } else {
+        return false
+    }
+}
+
+export const getUrlParameter = (loca, type) => {
+    let search = () => (location.href.indexOf('?') === -1 ? '' : location.href.slice(location.href.indexOf('?')));
+    let url = loca || location.search || search();
+    if (type === 'string') {
+        return url;
+    }
+    let theRequest = new Object();
+    if (url.indexOf('?') != -1) {
+        let str = url.split('?')[1];
+        let strs = str.split('&');
+        for (var i = 0; i < strs.length; i++) {
+            theRequest[strs[i].split('=')[0]] = strs[i].split('=')[1];
+        }
+    }
+    return theRequest;
+};

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "zetrix-connect-wallet-sdk-test",
+  "version": "1.0.0",
+  "description": "A library for mobile wallet and non-Chrome browsers to connect with the Zetrix blockchain.",
+  "main": "lib/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "qrcanvas": "^3.1.2"
+  }
+}