@0xsequence/provider 0.40.1 → 0.40.4

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

@@ -0,0 +1,121 @@
+import {
+  ProviderMessageRequest,
+  ProviderMessage,
+  EventType,
+  InitState,
+  WindowSessionParams,
+  OpenWalletIntent,
+  ProviderRpcError,
+  TransportSession
+} from '../../types'
+import { WalletRequestHandler } from '../wallet-request-handler'
+import { BaseWalletTransport } from '../base-wallet-transport'
+import { logger, base64DecodeObject } from '@0xsequence/utils'
+import { overrideLogs } from './overridelogs'
+
+// all lowercase is an annoying limitation of Unreal CEF BindUObject
+interface UnrealInjectedWalletWindow {
+  ue?: {
+    sequencewallettransport?: {
+      onmessagefromsequencejs?: (message: ProviderMessageRequest) => void
+      sendmessagetosequencejs: (message: string) => void
+    }
+  }
+}
+declare const window: Window & typeof globalThis & UnrealInjectedWalletWindow
+
+/**
+ * Initialized on Wallet side
+ */
+export class UnrealMessageHandler extends BaseWalletTransport {
+  constructor(walletRequestHandler: WalletRequestHandler) {
+    super(walletRequestHandler)
+    this._init = InitState.NIL
+  }
+
+  async register(windowHref?: string | URL) {
+    if (window.ue?.sequencewallettransport === undefined) {
+      return
+    }
+    overrideLogs('wallet')
+
+    // record open details (sessionId + default network) from the window url
+    const { search: rawParams } = new URL(windowHref || window.location.href)
+
+    let session: TransportSession | null = this.getUnrealTransportSession(rawParams)
+
+    // provider should always include sid when opening a new window
+    const isNewWindowSession = !!session.sessionId
+
+    // attempt to restore previous session in the case of a redirect or window reload
+    if (!isNewWindowSession) {
+      session = await this.getCachedTransportSession()
+    }
+
+    if (!session) {
+      logger.error('unreal session is undefined')
+      return
+    }
+
+    // listen for window-transport requests
+    window.ue.sequencewallettransport.onmessagefromsequencejs = this.onMessageFromUnreal
+    this._registered = true
+
+    // send open event to the app which opened us
+    this.open(session)
+      .then(opened => {
+        if (!opened) {
+          const err = `failed to open to network ${session?.networkId}`
+          logger.error(err)
+          this.notifyClose({ message: err } as ProviderRpcError)
+          window.close()
+        }
+      })
+      .catch(e => {
+        const err = `failed to open to network ${session?.networkId}, due to: ${e}`
+        logger.error(err)
+        this.notifyClose({ message: err } as ProviderRpcError)
+        window.close()
+      })
+  }
+
+  unregister() {
+    if (window.ue?.sequencewallettransport?.onmessagefromsequencejs === this.onMessageFromUnreal) {
+      delete window.ue.sequencewallettransport.onmessagefromsequencejs
+    }
+    this._registered = false
+  }
+
+  // onmessage is called when (the wallet) receives request messages from the dapp
+  // over the unreal json-messaging transport
+  private onMessageFromUnreal = (request: ProviderMessageRequest) => {
+    // Wallet always expects json-rpc request messages from a dapp
+
+    logger.debug('RECEIVED MESSAGE', request)
+
+    // Handle message via the base transport
+    this.handleMessage(request)
+  }
+
+  // sendMessage sends message to the dapp window
+  sendMessage(message: ProviderMessage<any>) {
+    if (message.type !== EventType.INIT && this._init !== InitState.OK) {
+      logger.error('impossible state, should not be calling postMessage until inited')
+      return
+    }
+    // prepare payload
+    const payload = JSON.stringify(message)
+
+    // post-message to app.
+    window.ue?.sequencewallettransport?.sendmessagetosequencejs(payload)
+  }
+
+  private getUnrealTransportSession = (windowParams: string | undefined): TransportSession => {
+    const params = new WindowSessionParams(windowParams)
+    return {
+      sessionId: params.get('sid'),
+      networkId: params.get('net'),
+      intent: base64DecodeObject<OpenWalletIntent>(params.get('intent'))
+    }
+  }
+}

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

@@ -0,0 +1,121 @@
+import { OpenWalletIntent, ProviderMessage, InitState, WindowSessionParams } from '../../types'
+import { BaseProviderTransport } from '../base-provider-transport'
+import { base64EncodeObject } from '@0xsequence/utils'
+import { overrideLogs } from './overridelogs'
+
+let registeredUnrealMessageProvider: UnrealMessageProvider | undefined
+
+// all lowercase is an annoying limitation of Unreal CEF BindUObject
+interface UnrealInjectedSequenceJSWindow {
+  ue?: {
+    sequencewallettransport?: {
+      onmessagefromwallet?: (message: ProviderMessage<any>) => void
+      sendmessagetowallet: (message: string) => void
+    }
+  }
+}
+
+declare const window: Window & typeof globalThis & UnrealInjectedSequenceJSWindow
+
+/**
+ * Initialized on dApp side
+ */
+export class UnrealMessageProvider extends BaseProviderTransport {
+  private walletURL: URL
+
+  constructor(walletAppURL: string) {
+    super()
+    this.walletURL = new URL(walletAppURL)
+  }
+
+  register = () => {
+    overrideLogs('dapp')
+    if (registeredUnrealMessageProvider) {
+      // overriding the registered message provider
+      registeredUnrealMessageProvider.unregister()
+      registeredUnrealMessageProvider = this
+    }
+
+    // listen for incoming messages from wallet
+    if (window.ue?.sequencewallettransport) {
+      window.ue.sequencewallettransport.onmessagefromwallet = this.onUnrealCallback
+    }
+    registeredUnrealMessageProvider = this
+
+    this._registered = true
+    console.log('registering transport!')
+  }
+
+  unregister = () => {
+    this._registered = false
+    this.closeWallet()
+
+    // disable message listener
+    if (registeredUnrealMessageProvider === this) {
+      registeredUnrealMessageProvider = undefined
+    }
+    if (window.ue?.sequencewallettransport?.onmessagefromwallet === this.onUnrealCallback) {
+      delete window.ue.sequencewallettransport.onmessagefromwallet
+    }
+
+    // clear event listeners
+    this.events.removeAllListeners()
+  }
+
+  openWallet = (path?: string, intent?: OpenWalletIntent, networkId?: string | number): void => {
+    if (this.isOpened()) {
+      // TODO focus wallet
+      console.log('wallet already open!')
+      return
+    }
+
+    console.log('opening wallet!')
+    // Instantiate new walletURL for this call
+    const walletURL = new URL(this.walletURL.href)
+    const windowSessionParams = new WindowSessionParams()
+
+    if (path) {
+      walletURL.pathname = path.toLowerCase()
+    }
+
+    // Set session, intent and network id on walletURL
+    this._init = InitState.NIL
+    this._sessionId = `${performance.now()}`
+    windowSessionParams.set('sid', this._sessionId)
+
+    if (intent) {
+      // encode intent as base64 url-encoded param
+      windowSessionParams.set('intent', base64EncodeObject(intent))
+    }
+    if (networkId) {
+      windowSessionParams.set('net', `${networkId}`)
+    }
+    // serialize params
+    walletURL.search = windowSessionParams.toString()
+
+    console.log('opening wallet to', walletURL.href)
+
+    window.open(walletURL.href)
+  }
+
+  closeWallet() {
+    this.close()
+  }
+
+  // onmessage, receives ProviderMessageResponse from the wallet unreal transport
+  private onUnrealCallback = (message: ProviderMessage<any>) => {
+    if (!message) {
+      throw new Error('ProviderMessage object is empty')
+    }
+
+    // handle message with base message provider
+    this.handleMessage(message)
+  }
+
+  // all lowercase is an annoying limitation of Unreal CEF BindUObject
+  sendMessage(message: ProviderMessage<unknown>) {
+    const postedMessage = typeof message !== 'string' ? JSON.stringify(message) : message
+    console.log('Sending message to wallet:', postedMessage)
+    window.ue?.sequencewallettransport?.sendmessagetowallet(postedMessage)
+  }
+}

package/src/transports/wallet-request-handler.ts

@@ -300,17 +300,17 @@ export class WalletRequestHandler implements ExternalProvider, JsonRpcHandler, P
 
           // Message must be prefixed with "\x19Ethereum Signed Message:\n"
           // as defined by EIP-191
-          message = prefixEIP191Message(message)
+          const prefixedMessage = prefixEIP191Message(message)
 
           // TODO:
           // if (process.env.TEST_MODE === 'true' && this.prompter === null) {
           if (this.prompter === null) {
             // prompter is null, so we'll sign from here
-            sig = await signer.signMessage(ethers.utils.arrayify(message), chainId)
+            sig = await signer.signMessage(prefixedMessage, chainId)
           } else {
             const promptResultForDeployment = await this.handleConfirmWalletDeployPrompt(this.prompter, signer, chainId)
             if (promptResultForDeployment) {
-              sig = await this.prompter.promptSignMessage({ chainId: chainId, message }, this.connectOptions)
+              sig = await this.prompter.promptSignMessage({ chainId: chainId, message: prefixedMessage }, this.connectOptions)
             }
           }
 

package/src/types.ts

@@ -247,7 +247,7 @@ export type OpenWalletIntent =
   | { type: 'jsonRpcRequest'; method: string }
 
 export interface MessageToSign {
-  message?: string
+  message?: Uint8Array
   typedData?: TypedData
   chainId?: number
 }

package/src/wallet.ts

@@ -19,9 +19,15 @@ import {
 } from '@0xsequence/network'
 import { WalletConfig, WalletState } from '@0xsequence/config'
 import { logger } from '@0xsequence/utils'
-import { JsonRpcProvider, JsonRpcSigner, ExternalProvider } from '@ethersproject/providers'
+import { JsonRpcProvider } from '@ethersproject/providers'
 import { Web3Provider, Web3Signer } from './provider'
-import { MuxMessageProvider, WindowMessageProvider, ProxyMessageProvider, ProxyMessageChannelPort } from './transports'
+import {
+  MuxMessageProvider,
+  WindowMessageProvider,
+  ProxyMessageProvider,
+  ProxyMessageChannelPort,
+  UnrealMessageProvider
+} from './transports'
 import { WalletSession, ProviderEventTypes, ConnectOptions, OpenWalletIntent, ConnectDetails } from './types'
 import { ethers } from 'ethers'
 import { ExtensionMessageProvider } from './transports/extension-transport/extension-message-provider'
@@ -29,14 +35,11 @@ import { LocalStore, ItemStore, LocalStorage } from './utils'
 import { WalletUtils } from './utils/index'
 
 import { Runtime } from 'webextension-polyfill-ts'
-import { sequence } from '../../0xsequence/src'
 
 export interface WalletProvider {
   connect(options?: ConnectOptions): Promise<ConnectDetails>
-  // authorize(options?: ConnectOptions): Promise<ConnectDetails>
   disconnect(): void
 
-  isOpened(): boolean
   isConnected(): boolean
   getSession(): WalletSession | undefined
 
@@ -45,6 +48,7 @@ export interface WalletProvider {
   getChainId(): Promise<number>
   getAuthChainId(): Promise<number>
 
+  isOpened(): boolean
   openWallet(path?: string, intent?: OpenWalletIntent, networkId?: string | number): Promise<boolean>
   closeWallet(): void
 
@@ -87,6 +91,7 @@ export class Wallet implements WalletProvider {
     windowMessageProvider?: WindowMessageProvider
     proxyMessageProvider?: ProxyMessageProvider
     extensionMessageProvider?: ExtensionMessageProvider
+    unrealMessageProvider?: UnrealMessageProvider
   }
 
   private networks: NetworkConfig[]
@@ -149,6 +154,10 @@ export class Wallet implements WalletProvider {
       //
       // this.transport.messageProvider.add(this.transport.extensionMessageProvider)
     }
+    if (this.config.transports?.unrealTransport?.enabled) {
+      this.transport.unrealMessageProvider = new UnrealMessageProvider(this.config.walletAppURL)
+      this.transport.messageProvider.add(this.transport.unrealMessageProvider)
+    }
     this.transport.messageProvider.register()
 
     // .....
@@ -238,13 +247,23 @@ export class Wallet implements WalletProvider {
     this.transport.messageProvider.on('walletContext', (walletContext: WalletContext) => {
       this.useSession({ walletContext: walletContext }, true)
     })
+  }
 
-    // Load existing session from localStorage
-    this.loadSession().then(session => {
+  loadSession = async (): Promise<WalletSession | undefined> => {
+    const data = await LocalStorage.getInstance().getItem('@sequence.session')
+    if (!data || data === '') {
+      return undefined
+    }
+    try {
+      const session = JSON.parse(data) as WalletSession
       if (session) {
         this.useSession(session, false)
       }
-    })
+      return session
+    } catch (err) {
+      logger.warn('loadSession failed, unable to parse session payload from storage.')
+      return undefined
+    }
   }
 
   connect = async (options?: ConnectOptions): Promise<ConnectDetails> => {
@@ -549,24 +568,10 @@ export class Wallet implements WalletProvider {
     this.transport.messageProvider!.once(event, fn)
   }
 
-  private loadSession = async (): Promise<WalletSession | undefined> => {
-    const data = await LocalStorage.getInstance().getItem('@sequence.session')
-    if (!data || data === '') {
-      return undefined
-    }
-    try {
-      const session = JSON.parse(data) as WalletSession
-      return session
-    } catch (err) {
-      logger.warn('loadSession failed, unable to parse session payload from localStorage.')
-      return undefined
-    }
-  }
-
-  private saveSession = (session: WalletSession) => {
+  private saveSession = async (session: WalletSession) => {
     logger.debug('wallet provider: saving session')
     const data = JSON.stringify(session)
-    LocalStorage.getInstance().setItem('@sequence.session', data)
+    await LocalStorage.getInstance().setItem('@sequence.session', data)
   }
 
   private useSession = async (session: WalletSession, autoSave: boolean = true) => {
@@ -698,6 +703,11 @@ export interface ProviderConfig {
       enabled: boolean
       runtime: Runtime.Static
     }
+
+    // Unreal Engine transport (optional)
+    unrealTransport?: {
+      enabled: boolean
+    }
   }
 
   // Sequence Wallet Modules Context override. By default (and recommended), the
@@ -720,11 +730,12 @@ export const DefaultProviderConfig: ProviderConfig = {
 
 let walletInstance: Wallet | undefined
 
-export const initWallet = (network?: string | number, config?: Partial<ProviderConfig>) => {
+export const initWallet = async (network?: string | number, config?: Partial<ProviderConfig>) => {
   if (walletInstance && walletInstance.isOpened()) {
     walletInstance.closeWallet()
   }
   walletInstance = new Wallet(network, config)
+  await walletInstance.loadSession()
   return walletInstance
 }