@0xsequence/provider 0.0.0-2021823181734

package/src/transports/mux-transport/mux-message-provider.ts

@@ -0,0 +1,160 @@
+import {
+  ProviderMessage, EventType, ProviderTransport,
+  ProviderEventTypes, ProviderMessageRequest, ProviderMessageResponse, WalletSession, OpenWalletIntent, ConnectDetails
+} from '../../types'
+
+import { JsonRpcRequest, JsonRpcResponseCallback } from '@0xsequence/network'
+
+export class MuxMessageProvider implements ProviderTransport {
+
+  private messageProviders: ProviderTransport[]
+  private provider: ProviderTransport | undefined
+
+  constructor(...messageProviders: ProviderTransport[]) {
+    this.messageProviders = messageProviders
+    this.provider = undefined
+  }
+
+  add(...messageProviders: ProviderTransport[]) {
+    this.messageProviders.push(...messageProviders)
+  }
+
+  register = () => {
+    if (this.messageProviders.length === 1) {
+      this.provider = this.messageProviders[0]
+      this.provider.register()
+      return
+    }
+
+    this.messageProviders.forEach(m => {
+      m.register()
+
+      m.once('open', () => {
+        // the first one to open is the winner, and others will be unregistered
+        if (!this.provider) {
+          this.provider = m
+
+          // unregister other providers
+          this.messageProviders.forEach(m => {
+            if (this.provider !== m) {
+              m.unregister()
+            }
+          })
+        }
+      })
+    })
+  }
+
+  unregister = () => {
+    this.messageProviders.forEach(m => m.unregister())
+    this.provider = undefined
+  }
+
+  openWallet = (path?: string, intent?: OpenWalletIntent, networkId?: string | number): void => {
+    if (this.provider) {
+      this.provider.openWallet(path, intent, networkId)
+      return
+    }
+    this.messageProviders.forEach(m => m.openWallet(path, intent, networkId))
+  }
+
+  closeWallet() {
+    if (this.provider) {
+      this.provider.closeWallet()
+    }
+  }
+
+  isOpened(): boolean {
+    if (this.provider) {
+      return this.provider.isOpened()
+    }
+    return false
+  }
+
+  isConnected(): boolean {
+    if (this.provider) {
+      return this.provider.isConnected()
+    }
+    return false
+  }
+
+  on<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]) {
+    if (this.provider) {
+      this.provider.on(event, fn)
+      return
+    }
+    this.messageProviders.forEach(m => {
+      m.on(event, fn)
+    })
+  }
+
+  once<K extends keyof ProviderEventTypes>(event: K, fn: ProviderEventTypes[K]) {
+    if (this.provider) {
+      this.provider.once(event, fn)
+      return
+    }
+    this.messageProviders.forEach(m => {
+      m.once(event, fn)
+    })
+  }
+
+  emit<K extends keyof ProviderEventTypes>(event: K, ...args: Parameters<ProviderEventTypes[K]>): boolean {
+    if (this.provider) {
+      return this.provider.emit(event, ...args)
+    }
+    for (let i=0; i < this.messageProviders.length; i++) {
+      this.messageProviders[i].emit(event, ...args)
+    }
+    return true
+  }
+
+  sendAsync = async (request: JsonRpcRequest, callback: JsonRpcResponseCallback, chainId?: number) => {
+    if (this.provider) {
+      this.provider.sendAsync(request, callback, chainId)
+      return
+    }
+    throw new Error('impossible state, wallet must be opened first')
+  }
+
+  sendMessage(message: ProviderMessage<any>) {
+    if (!message.idx || message.idx <= 0) {
+      throw new Error('message idx is empty')
+    }
+
+    if (this.provider) {
+      this.provider.sendMessage(message)
+    } else {
+      throw new Error('impossible state, wallet must be opened first')
+    }
+  }
+
+  sendMessageRequest = async (message: ProviderMessageRequest): Promise<ProviderMessageResponse> => {
+    if (this.provider) {
+      return this.provider.sendMessageRequest(message)
+    }
+    throw new Error('impossible state, wallet must be opened first')
+  }
+
+  handleMessage(message: ProviderMessage<any>): void {
+    if (this.provider) {
+      this.provider.handleMessage(message)
+      return
+    }
+    throw new Error('impossible state, wallet must be opened first')
+  }
+
+  waitUntilOpened = async (): Promise<WalletSession | undefined> => {
+    if (this.provider) {
+      return this.provider.waitUntilOpened()
+    }
+    return Promise.race(this.messageProviders.map(p => p.waitUntilOpened()))
+  }
+
+  waitUntilConnected = async (): Promise<ConnectDetails> => {
+    if (this.provider) {
+      return this.provider.waitUntilConnected()
+    }
+    throw new Error('impossible state, wallet must be opened first')
+  }
+
+}

package/src/transports/proxy-transport/index.ts

@@ -0,0 +1,3 @@
+export * from './proxy-message-channel'
+export * from './proxy-message-provider'
+export * from './proxy-message-handler'

package/src/transports/proxy-transport/proxy-message-channel.ts

@@ -0,0 +1,58 @@
+import { EventEmitter2 as EventEmitter } from 'eventemitter2'
+import { ProviderMessage, ProviderMessageTransport, ProviderEventTypes, TypedEventEmitter } from '../../types'
+
+export class ProxyMessageChannel {
+  app: ProxyMessageChannelPort
+  wallet: ProxyMessageChannelPort
+
+  constructor() {
+    const port1 = new ProxyMessageChannelPort()
+    const port2 = new ProxyMessageChannelPort()
+
+    port1.conn = port2
+    port2.conn = port1
+
+    this.app = port1
+    this.wallet = port2
+  }
+}
+
+export class ProxyMessageChannelPort implements ProviderMessageTransport {
+  conn: ProviderMessageTransport
+  events: TypedEventEmitter<ProxyEventTypes> = new EventEmitter() as TypedEventEmitter<ProxyEventTypes>
+
+
+  // handle messages which hit this port
+  handleMessage = (message: ProviderMessage<any>): void => {
+    throw new Error('ProxyMessageChannelPort is not registered')
+  }
+
+  // send messages to the connected port
+  sendMessage = (message: ProviderMessage<any>): void => {
+    this.conn.handleMessage(message)
+
+    // trigger events
+    if (message.type === 'open') {
+      this.events.emit('open', message as any)
+    }
+    if (message.type === 'close') {
+      this.events.emit('close', message as any)
+    }
+    if (message.type === 'connect') {
+      this.events.emit('connect', message as any)
+    }
+    if (message.type === 'disconnect') {
+      this.events.emit('disconnect', message as any)
+    }
+  }
+
+  on<K extends keyof ProxyEventTypes>(event: K, fn: ProxyEventTypes[K]) {
+    this.events.on(event, fn as any)
+  }
+
+  once<K extends keyof ProxyEventTypes>(event: K, fn: ProxyEventTypes[K]) {
+    this.events.once(event, fn as any)
+  }
+}
+
+export type ProxyEventTypes = Pick<ProviderEventTypes, 'open' | 'close' | 'connect' | 'disconnect'>

package/src/transports/proxy-transport/proxy-message-handler.ts

@@ -0,0 +1,46 @@
+import { BaseWalletTransport } from '../base-wallet-transport'
+import { WalletRequestHandler } from '../wallet-request-handler'
+import { InitState, ProviderMessage } from '../../types'
+import { ProxyMessageChannelPort } from './proxy-message-channel'
+
+export class ProxyMessageHandler extends BaseWalletTransport {
+
+  private port: ProxyMessageChannelPort
+
+  constructor(walletRequestHandler: WalletRequestHandler, port: ProxyMessageChannelPort) {
+    super(walletRequestHandler)
+    this.port = port
+    this._init = InitState.OK
+  }
+
+  register() {
+    this.port.handleMessage = (message: ProviderMessage<any>): void => {
+      this.handleMessage(message)
+    }
+    this._registered = true
+  }
+
+  // note: we can't decide whether to restore the session within register(), because session info is
+  // received asyncronously via EventType.OPEN after register() is executed.
+  // And in the case of a redirect/reload, EventType.OPEN is not sent at all, 
+  // because the wallet is already open.
+  //
+  // call this method from wallet redirect hander when a session restore is needed
+  restoreSession() {
+    const cachedSession = this.getCachedTransportSession()
+    if (cachedSession) {
+      this.open(cachedSession)
+    }
+  }
+
+  unregister() {
+    // @ts-ignore
+    this.port.handleMessage = undefined
+    this._registered = false
+  }
+
+  sendMessage(message: ProviderMessage<any>) {
+    this.port.sendMessage(message)
+  }
+
+}

package/src/transports/proxy-transport/proxy-message-provider.ts

@@ -0,0 +1,81 @@
+import { BaseProviderTransport } from '../base-provider-transport'
+
+import {
+  ProviderMessage, OpenState, OpenWalletIntent, EventType, InitState
+} from '../../types'
+
+import { ProxyMessageChannelPort, ProxyEventTypes } from './proxy-message-channel'
+
+export class ProxyMessageProvider extends BaseProviderTransport {
+
+  private port: ProxyMessageChannelPort
+  
+  constructor(port: ProxyMessageChannelPort) {
+    super()
+    this.state = OpenState.CLOSED
+    this.port = port    
+    if (!port) {
+      throw new Error('port argument cannot be empty')
+    }
+
+    // disable init handshake for proxy-transport, we set it to OK, to
+    // consider it in completed state.
+    this._init = InitState.OK
+  }
+
+  register = () => {
+    this.port.handleMessage = (message: ProviderMessage<any>): void => {
+      this.handleMessage(message)
+    }
+
+    this.on('open', (...args: Parameters<ProxyEventTypes['open']>) => {
+      this.port.events.emit('open', ...args)
+    })
+    this.on('close', (...args: Parameters<ProxyEventTypes['close']>) => {
+      this.port.events.emit('close', ...args)
+    })
+    this.on('connect', (...args: Parameters<ProxyEventTypes['connect']>) => {
+      this.port.events.emit('connect', ...args)
+    })
+    this.on('disconnect', (...args: Parameters<ProxyEventTypes['disconnect']>) => {
+      this.port.events.emit('disconnect', ...args)
+    })
+
+    this._registered = true
+  }
+
+  unregister = () => {
+    this._registered = false
+    this.closeWallet()
+    this.events.removeAllListeners()
+    // @ts-ignore
+    this.port.handleMessage = undefined
+  }
+
+  openWallet = (path?: string, intent?: OpenWalletIntent, networkId?: string | number): void => {
+    if (this.state === OpenState.CLOSED) {
+      this.state = OpenState.OPENING
+      const sessionId = `${performance.now()}`
+      this._sessionId = sessionId
+      this.sendMessage({
+        idx: -1, type: EventType.OPEN, data: {
+          path, intent, networkId, sessionId
+        }
+      })
+    }
+  }
+
+  closeWallet() {
+    this.sendMessage({
+      idx: -1, type: EventType.CLOSE, data: null
+    })
+    this.close()
+  }
+
+  sendMessage(message: ProviderMessage<any>) {
+    if (!message.idx) {
+      throw new Error('message idx is empty')
+    }
+    this.port.sendMessage(message)
+  }
+}