@onekeyfe/hd-web-sdk 0.0.1

package/src/iframe/index.ts

@@ -0,0 +1,73 @@
+import HttpTransport from '@onekeyfe/hd-transport-http';
+import {
+  PostMessageEvent,
+  IFRAME,
+  initLog,
+  parseMessage,
+  DataManager,
+  parseConnectSettings,
+  IFrameInit,
+  createIFrameMessage,
+  createErrorMessage,
+  initCore,
+  Core,
+  CORE_EVENT,
+} from '@onekeyfe/hd-core';
+import { getOrigin } from '../utils/urlUtils';
+import { sendMessage, createJsBridge } from '../utils/bridgeUtils';
+
+import JSBridgeConfig from './bridge-config';
+
+let _core: Core | undefined;
+const Log = initLog('IFrame');
+
+const handleMessage = (event: PostMessageEvent) => {
+  if (event.source === window || !event.data) return;
+
+  const message = parseMessage(event);
+
+  if (message.type === IFRAME.INIT) {
+    init(message.payload ?? {});
+  }
+};
+
+export async function init(payload: IFrameInit['payload']) {
+  if (DataManager.getSettings('origin')) return;
+
+  const settings = parseConnectSettings({
+    ...(payload.settings ?? {}),
+    isFrame: true,
+  });
+  // set origin manually
+  settings.origin = !origin || origin === 'null' ? payload.settings.origin : origin;
+
+  Log.enabled = !!settings.debug;
+
+  try {
+    _core = await initCore(settings, HttpTransport);
+    _core?.on(CORE_EVENT, messages => sendMessage(messages, false));
+  } catch (error) {
+    return createErrorMessage(error);
+  }
+
+  createJsBridge({
+    isHost: false,
+    remoteFrame: window.parent,
+    remoteFrameName: JSBridgeConfig.hostName,
+    selfFrameName: JSBridgeConfig.iframeName,
+    channel: JSBridgeConfig.channel,
+    targetOrigin: getOrigin(settings.parentOrigin as string),
+    receiveHandler: async messageEvent => {
+      const message = parseMessage(messageEvent);
+      Log.debug('Frame Bridge Receive message: ', message);
+
+      const response = await _core?.handleMessage(message);
+      Log.debug('Frame Bridge response data: ', response);
+      return response;
+    },
+  });
+
+  await sendMessage(createIFrameMessage(IFRAME.INIT_BRIDGE, {}), false);
+}
+
+window.addEventListener('message', handleMessage, false);

package/src/index.ts

@@ -0,0 +1,144 @@
+import EventEmitter from 'events';
+import HardwareSdk, {
+  ERRORS,
+  parseConnectSettings,
+  initLog,
+  enableLog,
+  PostMessageEvent,
+  IFRAME,
+  createErrorMessage,
+  parseMessage,
+  UI_EVENT,
+  CoreMessage,
+  ConnectSettings,
+  UiResponseEvent,
+} from '@onekeyfe/hd-core';
+import * as iframe from './iframe/builder';
+import JSBridgeConfig from './iframe/bridge-config';
+import { sendMessage, createJsBridge, hostBridge } from './utils/bridgeUtils';
+
+const eventEmitter = new EventEmitter();
+const Log = initLog('@onekey/connect');
+
+let _settings = parseConnectSettings();
+
+const handleMessage = async (message: CoreMessage) => {
+  switch (message.event) {
+    case UI_EVENT:
+      if (message.type === IFRAME.INIT_BRIDGE) {
+        iframe.initPromise.resolve();
+        return Promise.resolve({ success: true, payload: 'JSBridge Handshake Success' });
+      }
+
+      // pass UI event up
+      eventEmitter.emit(message.event, message);
+      eventEmitter.emit(message.type, message.payload);
+      break;
+
+    default:
+      Log.log('No need to be captured message', message.event);
+  }
+};
+
+const dispose = () => {
+  eventEmitter.removeAllListeners();
+  iframe.dispose();
+  _settings = parseConnectSettings();
+  window.removeEventListener('message', createJSBridge);
+};
+
+const uiResponse = (response: UiResponseEvent) => {
+  if (!iframe.instance) {
+    throw ERRORS.TypedError('Init_NotInitialized');
+  }
+  const { type, payload } = response;
+  sendMessage({ event: UI_EVENT, type, payload });
+};
+
+const cancel = () => {};
+
+const createJSBridge = (messageEvent: PostMessageEvent) => {
+  if (messageEvent.origin !== iframe.origin) {
+    return;
+  }
+  if (!hostBridge) {
+    createJsBridge({
+      isHost: true,
+      remoteFrame: iframe.instance?.contentWindow as Window,
+      remoteFrameName: JSBridgeConfig.iframeName,
+      selfFrameName: JSBridgeConfig.hostName,
+      channel: JSBridgeConfig.channel,
+      targetOrigin: iframe.origin,
+
+      receiveHandler: async messageEvent => {
+        const message = parseMessage(messageEvent);
+        console.log('Host Bridge Receive message: ', message);
+        const response = await handleMessage(message);
+        Log.debug('Host Bridge response: ', response);
+        return response;
+      },
+    });
+  }
+};
+
+const init = (settings: Partial<ConnectSettings>) => {
+  if (iframe.instance) {
+    throw ERRORS.TypedError('Init_AlreadyInitialized');
+  }
+
+  _settings = parseConnectSettings({ ..._settings, ...settings });
+
+  if (_settings.lazyLoad) {
+    _settings.lazyLoad = false;
+    return;
+  }
+
+  enableLog(!!settings.debug);
+
+  Log.debug('init');
+
+  window.addEventListener('message', createJSBridge);
+  window.addEventListener('unload', dispose);
+
+  iframe.init(_settings);
+};
+
+const call = async (params: any) => {
+  Log.debug('call : ', params);
+  // lazy load
+  if (!iframe.instance && !iframe.timeout) {
+    _settings = parseConnectSettings(_settings);
+    try {
+      init(_settings);
+    } catch (error) {
+      return createErrorMessage(error);
+    }
+  }
+
+  if (iframe.timeout) {
+    return createErrorMessage(ERRORS.TypedError('Init_IframeLoadFail'));
+  }
+
+  try {
+    const response = await sendMessage({ event: IFRAME.CALL, type: IFRAME.CALL, payload: params });
+    if (response) {
+      return response;
+    }
+
+    return createErrorMessage(ERRORS.TypedError('Call_NotResponse'));
+  } catch (error) {
+    Log.error('__call error: ', error);
+    return createErrorMessage(error);
+  }
+};
+
+const HardwareWebSdk = HardwareSdk({
+  eventEmitter,
+  init,
+  call,
+  cancel,
+  dispose,
+  uiResponse,
+});
+
+export default HardwareWebSdk;

package/src/utils/bridgeUtils.ts

@@ -0,0 +1,38 @@
+import { IJsBridgeIframeConfig, JsBridgeIframe } from '@onekeyfe/cross-inpage-provider-core';
+import { CoreMessage, initLog } from '@onekeyfe/hd-core';
+import JSBridgeConfig from '../iframe/bridge-config';
+
+// eslint-disable-next-line import/no-mutable-exports
+let frameBridge: JsBridgeIframe;
+// eslint-disable-next-line import/no-mutable-exports
+let hostBridge: JsBridgeIframe;
+
+const Log = initLog('[SendMessage]');
+
+export const createJsBridge = (params: IJsBridgeIframeConfig & { isHost: boolean }) => {
+  const bridge = new JsBridgeIframe(params);
+  if (params.isHost) {
+    hostBridge = bridge;
+  } else {
+    frameBridge = bridge;
+  }
+};
+
+export const sendMessage = async (messages: CoreMessage, isHost = true): Promise<any> => {
+  const bridge = isHost ? hostBridge : frameBridge;
+
+  try {
+    Log.debug('request: ', messages);
+    const result = await bridge?.request({
+      scope: JSBridgeConfig.scope,
+      data: { ...messages },
+    });
+    Log.debug('response: ', result);
+    return result;
+  } catch (error) {
+    Log.error(error);
+    throw error;
+  }
+};
+
+export { frameBridge, hostBridge };

package/src/utils/urlUtils.ts

@@ -0,0 +1,7 @@
+export const getOrigin = (url: string) => {
+  if (typeof url !== 'string') return 'unknown';
+  if (url.indexOf('file://') === 0) return 'file://';
+  // eslint-disable-next-line no-useless-escape
+  const parts = url.match(/^.+\:\/\/[^\/]+/);
+  return Array.isArray(parts) && parts.length > 0 ? parts[0] : 'unknown';
+};

package/static/iframe.html

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>OneKeyConnect | OneKey</title>
+    <meta name="description" content="" />
+    <meta name="keywords" content="" />
+    <meta name="author" content="OneKey hi@onekey.so" />
+    <meta name="robots" content="index, follow" />
+    <meta name="title" content="OneKeyConnect | OneKey" />
+    <meta http-equiv="Cache-control" content="no-cache" />
+    <meta http-equiv="pragma" content="no-cache" />
+</head>
+<body>
+
+    <script type="text/javascript">
+
+        window.parent.postMessage({
+            event: 'UI_EVENT',
+            type: 'iframe-bootstrap',
+        }, '*');
+
+        const iframeScript = document.createElement('script');
+        iframeScript.setAttribute('type', 'text/javascript');
+        iframeScript.setAttribute('src', '<%= htmlWebpackPlugin.files.js[0] %>');
+        iframeScript.setAttribute('async', 'false');
+        document.body.appendChild(iframeScript);
+    </script>
+</body>
+</html>

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+  },
+  "include": ["./src"],
+  "exclude": ["./webpack"]
+}

package/webpack/dev.webpack.config.ts

@@ -0,0 +1,32 @@
+import path from 'path';
+import fs from 'fs';
+import { merge } from 'webpack-merge';
+import { WebpackPluginServe } from 'webpack-plugin-serve';
+
+import config from './webpack.config';
+import iframe from './iframe.webpack.config';
+import prod from './prod.webpack.config';
+
+const dev = {
+  mode: 'development',
+  watch: true,
+  devtool: 'source-map',
+  entry: {
+    'onekey-js-sdk': path.resolve(__dirname, '../src/index.ts'),
+  },
+  output: config.output,
+  resolve: config.resolve,
+  plugins: [
+    new WebpackPluginServe({
+      port: 8088,
+      hmr: true,
+      https: {
+        key: fs.readFileSync(path.join(__dirname, '../webpack/https_dev.key')),
+        cert: fs.readFileSync(path.join(__dirname, '../webpack/https_dev.crt')),
+      },
+      static: [path.join(__dirname, '../build')],
+    }),
+  ],
+};
+
+export default merge([prod, iframe, dev]);

package/webpack/https_dev.crt

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIJAI8iRZxUqx3yMA0GCSqGSIb3DQEBBQUAMF8xCzAJBgNV
+BAYTAkdCMRAwDgYDVQQIDAdFbmdsYW5kMREwDwYDVQQHDAhCcmlnaHRvbjEXMBUG
+A1UECgwOSGFsbG1hcmtkZXNpZ24xEjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0yMjA1
+MjQxMjMxNDRaFw0zMjA1MjExMjMxNDRaMF8xCzAJBgNVBAYTAkdCMRAwDgYDVQQI
+DAdFbmdsYW5kMREwDwYDVQQHDAhCcmlnaHRvbjEXMBUGA1UECgwOSGFsbG1hcmtk
+ZXNpZ24xEjAQBgNVBAMMCWxvY2FsaG9zdDCCAiIwDQYJKoZIhvcNAQEBBQADggIP
+ADCCAgoCggIBAMuoHL3433X2wKUPFlFikZUBfE2zrgyvsRtIMvRGQgtPagWFwOp+
+JTP9s6Js57UOGN/qhn+tb8iod9NZF+c4hQT40CyOws9wwZTvbxSDQ/TfHgTCplmx
+gkcoYTWofQQOZh0gpJkW5/65uctT/XbvpZQHFai7XcdizyEC/hkg4nfncf8ysBFz
+PT0g3gpfLLD4J7i4O0hAjbtvci5gMH7qGaxFzL6yLRLTNdtfjFWS/W0rhTXhvzb5
+j8Vp+uNelBAVlvgJuU7e6iY/cRGNsZaf3FWLHKcWmfwjPTctAjy7ePGq0Ycf8/ZX
+vG2yCWk4ErArEq3SR7u+NvJIRaFATyBudp9gy2kIfdYus86XhWXfkcP+JcwJAP/e
+4hhO75IEGqsr+z2VdXhIWn1YULUFwVNsbQlt7+g97nfFywzmTv1ocURpLi6MoLev
+9e17MxYFiXdAaUrlavNRtkwlk+yqEzza3hVCkYwBKCZpQC0D+RlgHphiTkbH1gsm
+/AOkEencxtCwOJOYCtbL+K5nIXhKi+v9NDg8AqWjU2tH+p5jsp//wuxCO68LppFG
+/BElcG2WvhRfLHn0beY5JL91OAW7FNyPAjyXVBiBlak+hs/rg6kruyjBJIMVBprJ
+of7aF42lQcw5OdxFUSTNv/LDSMe/IrS00mkPSz5nuXsrSDhHXo3M4Z8VAgMBAAGj
+GDAWMBQGA1UdEQQNMAuCCWxvY2FsaG9zdDANBgkqhkiG9w0BAQUFAAOCAgEAXTLX
+fpDcB914FHbQYxwz9tvZYg8SUn7V4F6rmmr6FNmUU38Un6/VArGE0vKgwo63qjzu
+kk/iwIbsLhw3N1oEANAAOTnO9XHul/HElsUbvQmQm7YhN9VU52ReBc0OXcAvAWqm
+Y/m8qySan/x7ycVsHBy4tn/6kZ68cnpsm3I/Ik7NQnjU9FZSwpEVWVVlvyJl0pZK
+1cns8Db+4u2flTru0DkHht4bGUKH5bL78PWcLmJPD1noLP8pKw/vXUTmSS0IlikP
+lf90yv44MnP8wKudTapmAOlbJxehfNZpBhQ0h3N3HW9D/PR3yBgsIvMYdPw6aphX
+MGM8X0U18VZsg0VajvxvFUwgTh639UoYMsLhq/haPmIOjMbDpl8MylM/t2PQltOX
+dYFT5iVcthYHbk+U0VLwrKJfhtofWz5mexrGNWCukNl6JakaY7GkXv8ICW7iSe3S
+A0R/xrFzAcRIZN6odq/uA1BXBADOSEk/hyEjWS1dE/8JQ6ioK9eX5EF6sGfuZLGp
+QK4b/HlU5jqQ0b1EArIXe1FrDWe5Mo/E1TZUTHe/T0tvpOyVuRc75iSXaefLz84R
+9Xp/3RijDJzeyceVUbt6cpqeuwbFEVZCF+uFD/2wfVcDVhTWnG66wpbJRIxR+Tk2
+ZHskZ7S/V9kQGqp01hu9EwXcbkizXd0C7bL+Ng0=
+-----END CERTIFICATE-----

package/webpack/https_dev.key

@@ -0,0 +1,51 @@
+-----BEGIN RSA PRIVATE KEY-----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==
+-----END RSA PRIVATE KEY-----

package/webpack/iframe.webpack.config.ts

@@ -0,0 +1,66 @@
+import path from 'path';
+import webpack from 'webpack';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import CopyWebpackPlugin from 'copy-webpack-plugin';
+import config from './webpack.config';
+
+const BUILD = path.resolve(__dirname, '../build');
+
+export default {
+  target: 'web',
+  mode: 'production',
+  devtool: 'source-map',
+  entry: {
+    iframe: path.resolve(__dirname, '../src/iframe/index.ts'),
+  },
+  output: {
+    filename: 'js/[name].[contenthash].js',
+    path: BUILD,
+    publicPath: './',
+  },
+  module: {
+    rules: [
+      {
+        test: /\.m?js/,
+        resolve: {
+          fullySpecified: false,
+        },
+      },
+      {
+        test: /\.(js|ts)$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'babel-loader',
+          options: {
+            presets: ['@babel/preset-typescript'],
+          },
+        },
+      },
+    ],
+  },
+  resolve: config.resolve,
+
+  performance: {
+    hints: false,
+  },
+
+  plugins: [
+    new webpack.ProvidePlugin({
+      Buffer: ['buffer', 'Buffer'],
+      Promise: ['es6-promise', 'Promise'],
+      process: 'process/browser',
+    }),
+
+    new CopyWebpackPlugin({
+      patterns: [{ from: '../../packages/core/src/data', to: `${BUILD}/data` }],
+    }),
+
+    new HtmlWebpackPlugin({
+      chunks: ['iframe'],
+      filename: 'iframe.html',
+      template: path.resolve(__dirname, '../static/iframe.html'),
+      minify: false,
+      inject: false,
+    }),
+  ],
+};

package/webpack/prod.webpack.config.ts

@@ -0,0 +1,61 @@
+import path from 'path';
+import TerserPlugin from 'terser-webpack-plugin';
+import config from './webpack.config';
+
+const prodConfig = {
+  target: 'web',
+  mode: 'production',
+  devtool: 'hidden-source-map',
+  entry: {
+    'onekey-js-sdk': path.resolve(__dirname, '../src/index.ts'),
+    'onekey-js-sdk.min': path.resolve(__dirname, '../src/index.ts'),
+  },
+  output: config.output,
+
+  module: {
+    rules: [
+      {
+        test: /\.m?js/,
+        resolve: {
+          fullySpecified: false,
+        },
+      },
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        use: ['babel-loader'],
+      },
+      {
+        test: /\.ts$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'babel-loader',
+          options: {
+            presets: ['@babel/preset-typescript'],
+            plugins: ['@babel/plugin-proposal-optional-chaining'],
+          },
+        },
+      },
+    ],
+  },
+  resolve: config.resolve,
+  performance: {
+    hints: false,
+  },
+
+  optimization: {
+    minimizer: [
+      new TerserPlugin({
+        exclude: /onekey-js-sdk.js/,
+        extractComments: false,
+        terserOptions: {
+          format: {
+            comments: false,
+          },
+        },
+      }),
+    ],
+  },
+};
+
+export default prodConfig;

package/webpack/webpack.config.ts

@@ -0,0 +1,17 @@
+import path from 'path';
+
+export default {
+  output: {
+    filename: '[name].js',
+    path: path.resolve(__dirname, '../build'),
+    publicPath: './',
+    library: 'onekey-js-sdk',
+    libraryTarget: 'umd',
+    libraryExport: 'default',
+  },
+  resolve: {
+    modules: ['node_modules'],
+    mainFields: ['browser', 'module', 'main'],
+    extensions: ['.ts', '.js'],
+  },
+};