fix(dapp-sdk,core-splice-provider): minor code cleanup (#1007)

Signed-off-by: Alex Matson <[email protected]>

Author: alexmatson-da

core/splice-provider/src/SpliceProviderHttp.ts

@@ -17,16 +17,15 @@ export class SpliceProviderHttp extends SpliceProviderBase {
     private transport: HttpTransport
 
     private openSocket(url: URL): Socket {
-        // Assumes the RPC URL is on /rpc, and the socket URL is the same but without the /rpc path.
-        const socketUrl = new URL(url.href)
-        socketUrl.pathname = ''
+        // Assumes the socket URL is accessed directly on the host w/o the API path.
+        const socketUri = url.origin
 
         if (this.socket) {
             console.debug('SpliceProviderHttp: closing existing socket')
             this.socket.disconnect()
         }
 
-        const socket = io(socketUrl.href, {
+        const socket = io(socketUri, {
             forceNew: true,
             auth: this.sessionToken
                 ? {

sdk/dapp-sdk/src/provider.ts

@@ -32,35 +32,25 @@ import { ErrorCode } from './error.js'
  */
 export class Provider implements SpliceProvider {
     private providerType: ProviderType
-    private httpProvider?: SpliceProvider
-    private windowProvider?: SpliceProvider
+    private provider: SpliceProvider
 
     constructor({ walletType, url }: DiscoverResult, sessionToken?: string) {
         if (walletType == 'extension') {
             this.providerType = ProviderType.WINDOW
-            this.windowProvider = new SpliceProviderWindow()
+            this.provider = new SpliceProviderWindow()
         } else if (walletType == 'remote') {
             this.providerType = ProviderType.HTTP
-            this.httpProvider = new SpliceProviderHttp(
-                new URL(url),
-                sessionToken
-            )
+            this.provider = new SpliceProviderHttp(new URL(url), sessionToken)
         } else {
             throw new Error(`Unsupported wallet type ${walletType}`)
         }
     }
 
-    private getProvider(): SpliceProvider {
-        if (this.providerType === ProviderType.WINDOW)
-            return this.windowProvider!
-        return this.httpProvider!
-    }
-
     request<T>(args: RequestPayload): Promise<T> {
         if (this.providerType === ProviderType.WINDOW)
-            return this.getProvider().request(args)
+            return this.provider.request(args)
 
-        const controller = dappController(this.getProvider())
+        const controller = dappController(this.provider)
         switch (args.method) {
             case 'status':
                 return controller.status() as Promise<T>
@@ -90,18 +80,18 @@ export class Provider implements SpliceProvider {
     }
 
     on<T>(event: string, listener: EventListener<T>): SpliceProvider {
-        return this.getProvider().on(event, listener)
+        return this.provider.on(event, listener)
     }
 
     emit<T>(event: string, ...args: T[]): boolean {
-        return this.getProvider().emit(event, args)
+        return this.provider.emit(event, args)
     }
 
     removeListener<T>(
         event: string,
         listenerToRemove: EventListener<T>
     ): SpliceProvider {
-        return this.getProvider().removeListener(event, listenerToRemove)
+        return this.provider.removeListener(event, listenerToRemove)
     }
 }