@portal-hq/connect 0.3.1

package/lib/commonjs/components/scanner/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const react_native_1 = require("react-native");
+const WalletScanner = () => {
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement(react_native_1.Text, null, "Yo!")));
+};
+exports.default = WalletScanner;

package/lib/commonjs/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class PortalConnect {
+    constructor({ portal, websocketServer = 'connect.portalhq.io', }) {
+        this.portal = portal;
+        this.websocketServer = websocketServer;
+    }
+    /**
+     * Establishes a websocket connection with the Connect Proxy and dispatches the binding
+     * of websocket events for the newly established socket
+     *
+     * @param connectionString The URI to ask the Connect Proxy to create a websocket connection to
+     */
+    connect(uri) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.socket) {
+                this.socket.close();
+            }
+            this.socket = new WebSocket(`wss://${this.websocketServer}`);
+            this.bindToSocketEvents(this.socket, uri);
+        });
+    }
+    /**
+     * Adds event bindings to a websocket connection
+     * - on open, a `connect` event is dispatched via the socket to establish a bridge connection
+     *
+     * @param socket The websocket connection to bind events to
+     * @param uri The URI to ask the Connect Proxy to create a websocket connection to
+     */
+    bindToSocketEvents(socket, uri) {
+        /**
+         * Initial websocket handler fired when connection with the proxy server is established
+         * - Fires a subsequent call over the websocket to notify the proxy of the uri to connect to
+         */
+        socket.onopen = () => __awaiter(this, void 0, void 0, function* () {
+            const { address, chainId } = this.portal.provider;
+            // Tell the proxy server where to connect to downstream
+            socket.send(JSON.stringify({
+                event: 'connect',
+                data: {
+                    address,
+                    chainId,
+                    uri,
+                },
+            }));
+        });
+        /**
+         * Handles all incoming messages over the websocket connection
+         * (inbound messages proxied via the relay)
+         * @param messageEvent
+         * @returns
+         */
+        socket.onmessage = (messageEvent) => __awaiter(this, void 0, void 0, function* () {
+            const message = JSON.parse(messageEvent.data);
+            switch (message.event) {
+                case 'close':
+                    socket.close();
+                    break;
+                case 'connected':
+                    const { active } = message.data;
+                    if (!active) {
+                        // Proxy is not connected to the bridge
+                        console.warn(`PortalConnect could not establish a connection to the relay.`);
+                        return;
+                    }
+                    break;
+                case 'session_request':
+                    const { id, params, topic } = message.data;
+                    // Sign the transaction and get back a transaction hash
+                    const txHash = yield this.handleProviderRequest(params.request.method, params.request.params);
+                    // Let the server know the transaction hash
+                    socket.send(JSON.stringify({
+                        event: 'signatureReceived',
+                        data: {
+                            topic,
+                            transactionHash: txHash,
+                            transactionId: id,
+                        },
+                    }));
+                    break;
+                default:
+                    console.log(`Recieved unsupported event "${message.event}". Ignoring.`);
+                    break;
+            }
+        });
+    }
+    /**
+     * Proxies inbound requests to the Portal provider
+     *
+     * @param method The method for the provider request
+     * @param params The params for the provider request
+     *
+     * @returns The result of the provider request
+     */
+    handleProviderRequest(method, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Pass the request along to the provider
+            const result = yield this.portal.provider.request({ method, params });
+            return result;
+        });
+    }
+}
+exports.default = PortalConnect;

package/lib/esm/components/scanner/index.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Text } from 'react-native';
+const WalletScanner = () => {
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Text, null, "Yo!")));
+};
+export default WalletScanner;

package/lib/esm/index.js

@@ -0,0 +1,110 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class PortalConnect {
+    constructor({ portal, websocketServer = 'connect.portalhq.io', }) {
+        this.portal = portal;
+        this.websocketServer = websocketServer;
+    }
+    /**
+     * Establishes a websocket connection with the Connect Proxy and dispatches the binding
+     * of websocket events for the newly established socket
+     *
+     * @param connectionString The URI to ask the Connect Proxy to create a websocket connection to
+     */
+    connect(uri) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.socket) {
+                this.socket.close();
+            }
+            this.socket = new WebSocket(`wss://${this.websocketServer}`);
+            this.bindToSocketEvents(this.socket, uri);
+        });
+    }
+    /**
+     * Adds event bindings to a websocket connection
+     * - on open, a `connect` event is dispatched via the socket to establish a bridge connection
+     *
+     * @param socket The websocket connection to bind events to
+     * @param uri The URI to ask the Connect Proxy to create a websocket connection to
+     */
+    bindToSocketEvents(socket, uri) {
+        /**
+         * Initial websocket handler fired when connection with the proxy server is established
+         * - Fires a subsequent call over the websocket to notify the proxy of the uri to connect to
+         */
+        socket.onopen = () => __awaiter(this, void 0, void 0, function* () {
+            const { address, chainId } = this.portal.provider;
+            // Tell the proxy server where to connect to downstream
+            socket.send(JSON.stringify({
+                event: 'connect',
+                data: {
+                    address,
+                    chainId,
+                    uri,
+                },
+            }));
+        });
+        /**
+         * Handles all incoming messages over the websocket connection
+         * (inbound messages proxied via the relay)
+         * @param messageEvent
+         * @returns
+         */
+        socket.onmessage = (messageEvent) => __awaiter(this, void 0, void 0, function* () {
+            const message = JSON.parse(messageEvent.data);
+            switch (message.event) {
+                case 'close':
+                    socket.close();
+                    break;
+                case 'connected':
+                    const { active } = message.data;
+                    if (!active) {
+                        // Proxy is not connected to the bridge
+                        console.warn(`PortalConnect could not establish a connection to the relay.`);
+                        return;
+                    }
+                    break;
+                case 'session_request':
+                    const { id, params, topic } = message.data;
+                    // Sign the transaction and get back a transaction hash
+                    const txHash = yield this.handleProviderRequest(params.request.method, params.request.params);
+                    // Let the server know the transaction hash
+                    socket.send(JSON.stringify({
+                        event: 'signatureReceived',
+                        data: {
+                            topic,
+                            transactionHash: txHash,
+                            transactionId: id,
+                        },
+                    }));
+                    break;
+                default:
+                    console.log(`Recieved unsupported event "${message.event}". Ignoring.`);
+                    break;
+            }
+        });
+    }
+    /**
+     * Proxies inbound requests to the Portal provider
+     *
+     * @param method The method for the provider request
+     * @param params The params for the provider request
+     *
+     * @returns The result of the provider request
+     */
+    handleProviderRequest(method, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Pass the request along to the provider
+            const result = yield this.portal.provider.request({ method, params });
+            return result;
+        });
+    }
+}
+export default PortalConnect;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@portal-hq/connect",
+  "version": "0.3.1",
+  "main": "lib/commonjs/index",
+  "module": "lib/esm/index",
+  "source": "src/index",
+  "types": "src/index",
+  "license": "MIT",
+  "files": [
+    "src",
+    "lib",
+    "types.d.ts"
+  ],
+  "scripts": {
+    "coverage": "jest --collect-coverage",
+    "prepare": "yarn prepare:cjs && yarn prepare:esm",
+    "prepare:cjs": "tsc --outDir lib/commonjs --module commonjs",
+    "prepare:esm": "tsc --outDir lib/esm --module es2015 --target es2015",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@babel/preset-typescript": "^7.18.6",
+    "@types/jest": "^29.2.0",
+    "jest": "^29.2.1",
+    "jest-environment-jsdom": "^29.2.2",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.8.4"
+  },
+  "peerDependencies": {
+    "@portal-hq/core": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/src/index.ts

@@ -0,0 +1,136 @@
+import Portal from '@portal-hq/core'
+import type {
+  ConnectResult,
+  PortalConnectOptions,
+  SessionRequest,
+  WebsocketMessage,
+} from '../types'
+
+class PortalConnect {
+  public portal: Portal
+  public socket?: WebSocket
+  public websocketServer: string
+
+  constructor({
+    portal,
+    websocketServer = 'connect.portalhq.io',
+  }: PortalConnectOptions) {
+    this.portal = portal
+    this.websocketServer = websocketServer
+  }
+
+  /**
+   * Establishes a websocket connection with the Connect Proxy and dispatches the binding
+   * of websocket events for the newly established socket
+   *
+   * @param connectionString The URI to ask the Connect Proxy to create a websocket connection to
+   */
+  public async connect(uri: string): Promise<void> {
+    if (this.socket) {
+      this.socket.close()
+    }
+
+    this.socket = new WebSocket(`wss://${this.websocketServer}`)
+    this.bindToSocketEvents(this.socket, uri)
+  }
+
+  /**
+   * Adds event bindings to a websocket connection
+   * - on open, a `connect` event is dispatched via the socket to establish a bridge connection
+   *
+   * @param socket The websocket connection to bind events to
+   * @param uri The URI to ask the Connect Proxy to create a websocket connection to
+   */
+  private bindToSocketEvents(socket: WebSocket, uri: string): void {
+    /**
+     * Initial websocket handler fired when connection with the proxy server is established
+     * - Fires a subsequent call over the websocket to notify the proxy of the uri to connect to
+     */
+    socket.onopen = async () => {
+      const { address, chainId } = this.portal.provider
+
+      // Tell the proxy server where to connect to downstream
+      socket.send(
+        JSON.stringify({
+          event: 'connect',
+          data: {
+            address,
+            chainId,
+            uri,
+          },
+        }),
+      )
+    }
+
+    /**
+     * Handles all incoming messages over the websocket connection
+     * (inbound messages proxied via the relay)
+     * @param messageEvent
+     * @returns
+     */
+    socket.onmessage = async (messageEvent: MessageEvent) => {
+      const message = JSON.parse(messageEvent.data) as WebsocketMessage
+
+      switch (message.event) {
+        case 'close':
+          socket.close()
+          break
+        case 'connected':
+          const { active } = message.data as ConnectResult
+          if (!active) {
+            // Proxy is not connected to the bridge
+            console.warn(
+              `PortalConnect could not establish a connection to the relay.`,
+            )
+            return
+          }
+          break
+        case 'session_request':
+          const { id, params, topic } = message.data as SessionRequest
+          // Sign the transaction and get back a transaction hash
+          const txHash = await this.handleProviderRequest(
+            params.request.method,
+            params.request.params,
+          )
+
+          // Let the server know the transaction hash
+          socket.send(
+            JSON.stringify({
+              event: 'signatureReceived',
+              data: {
+                topic,
+                transactionHash: txHash,
+                transactionId: id,
+              },
+            }),
+          )
+          break
+        default:
+          console.log(
+            `Recieved unsupported event "${message.event}". Ignoring.`,
+          )
+          break
+      }
+    }
+  }
+
+  /**
+   * Proxies inbound requests to the Portal provider
+   *
+   * @param method The method for the provider request
+   * @param params The params for the provider request
+   *
+   * @returns The result of the provider request
+   */
+  private async handleProviderRequest(
+    method: string,
+    params: any,
+  ): Promise<any> {
+    // Pass the request along to the provider
+    const result = await this.portal.provider.request({ method, params })
+
+    return result
+  }
+}
+
+export default PortalConnect

package/types.d.ts

@@ -0,0 +1,47 @@
+import Portal from '@portal-hq/core'
+
+interface ConnectResult {
+  active: boolean
+  expiry: number
+  peerMetadata: PeerMetadata
+  relay: ProtocolOptions
+  topic: string
+}
+
+interface PeerMetadata {
+  name: string
+  description: string
+  url: string
+  icons: string[]
+}
+
+interface PortalConnectOptions {
+  portal: Portal
+  websocketServer?: string
+}
+
+interface ProtocolOptions {
+  protocol: string
+  data?: string
+}
+
+interface ProviderRequestPayload {
+  chainId: string
+  request: ProviderRequestData
+}
+
+interface ProviderRequestData {
+  method: string
+  params: any
+}
+
+interface SessionRequest {
+  id: string
+  params: ProviderRequestPayload
+  topic: string
+}
+
+interface WebsocketMessage {
+  event: string
+  data: ConnectResult | SessionRequest
+}