fix: wip

Author: elribonazo

packages/sdk-multichain/src/connect.test.ts

@@ -170,6 +170,7 @@ function testSuite<T extends MultichainOptions>({ platform, createSDK, options:
 			t.expect(sdk.state).toBe('connected');
 			t.expect(sdk.storage).toBeDefined();
 			t.expect(sdk.transport).toBeDefined();
+			t.expect(sdk.provider).toBeDefined();
 
 			const { sessionScopes, expiry: _, ...rest } = mockSessionData;
 			const expectedSessionResponse = {
@@ -198,6 +199,7 @@ function testSuite<T extends MultichainOptions>({ platform, createSDK, options:
 			sdk = await createSDK(testOptions);
 			t.expect(sdk.state).toBe('connected');
 			t.expect(sdk.transport).toBeDefined();
+			t.expect(sdk.provider).toBeDefined();
 			t.expect(sdk.storage).toBeDefined();
 
 			await t.expect(sdk.storage.getTransport()).resolves.toBe(transportString);
@@ -219,6 +221,7 @@ function testSuite<T extends MultichainOptions>({ platform, createSDK, options:
 
 			sdk = await createSDK(testOptions);
 			t.expect(sdk.transport).toBeDefined();
+			t.expect(sdk.provider).toBeDefined();
 			t.expect(sdk.storage).toBeDefined();
 			t.expect(sdk.state).toBe('connected');
 
@@ -410,6 +413,10 @@ function testSuite<T extends MultichainOptions>({ platform, createSDK, options:
 
 			sdk = await createSDK(testOptions);
 			await sdk.connect(scopes, caipAccountIds);
+			t.expect(sdk.state).toBe('connected');
+			t.expect(sdk.provider).toBeDefined();
+			t.expect(sdk.transport).toBeDefined();
+
 			await t.expect(sdk.disconnect()).rejects.toThrow('Failed to disconnect transport');
 		});
 
@@ -423,6 +430,8 @@ function testSuite<T extends MultichainOptions>({ platform, createSDK, options:
 				sdk = await createSDK(testOptions);
 
 				t.expect(sdk.state).toBe('connected');
+				t.expect(sdk.provider).toBeDefined();
+				t.expect(sdk.transport).toBeDefined();
 
 				t.expect(mockedData.mockDappClient.state).toBe('CONNECTED');
 				await mockedData.mockDappClient.disconnect();

packages/sdk-multichain/src/domain/multichain/index.ts

@@ -25,7 +25,6 @@ export abstract class MultichainCore extends EventEmitter<SDKEvents> {
 	abstract provider: MultichainApiClient<RPCAPI>;
 	abstract transport: Transport;
 
-	abstract getCurrentSession(): Promise<SessionData | undefined>;
 	/**
 	 * Establishes a connection to the multichain provider, or re-use existing session
 	 *

packages/sdk-multichain/src/multichain/index.ts

@@ -124,24 +124,19 @@ export class MultichainSDK extends MultichainCore {
 		analytics.enable();
 	}
 
-	private async onTransportNotification(payload: unknown) {
-		if (typeof payload === 'object' && payload !== null && 'data' in payload) {
-			const data = payload.data as Record<string, unknown>;
-			if ('method' in data && data.method === 'wallet_sessionChanged') {
-				const session = data.params as SessionData;
-				this.emit('wallet_sessionChanged', Object.keys(session?.sessionScopes ?? {}).length > 0 ? session : undefined);
-			} else {
-				this.emit(data.method as string, data.params);
-			}
+	private async onTransportNotification(payload: any) {
+		if (typeof payload === 'object' && payload !== null && 'method' in payload) {
+			this.emit(payload.method as string, payload.params || payload.result);
 		}
 	}
 
 	private async getStoredTransport() {
 		const { ui } = this.options;
 		const { preferExtension = true, headless: _headless = false } = ui;
-
+		logger(`Fetching the stored transport`);
 		const transportType = await this.storage.getTransport();
 		if (transportType) {
+			logger(`Transport found: ${transportType}`);
 			if (transportType === TransportType.Browser) {
 				//Check if the user still have the extension or not return the transport
 				if (hasExtension() && preferExtension) {
@@ -162,35 +157,22 @@ export class MultichainSDK extends MultichainCore {
 			await this.storage.removeTransport();
 		}
 
+		logger(`No transport found`);
 		return undefined;
 	}
 
-	private async getActiveSession() {
-		const request = await this.transport.request({ method: 'wallet_getSession' });
-		const response = request.result as SessionData;
-		return response;
-	}
-
 	private async setupTransport() {
 		const transport = await this.getStoredTransport();
 		if (transport) {
+			logger(`Transport returned, connecting to transport`);
 			if (!this.transport.isConnected()) {
 				this.state = 'connecting';
 				await this.transport.connect();
 				this.state = 'connected';
+				logger(`Transport connected`);
 			}
-
-			const session = await this.getActiveSession();
+			logger(`Transport provider create`);
 			this.__provider = getMultichainClient({ transport });
-			//Add event listeners to the transport
-			if (session && Object.keys(session.sessionScopes ?? {}).length > 0) {
-				// No listeners can exist in here so we need onResumeSession event on constructor
-				this.options.transport?.onNotification?.({
-					method: 'wallet_sessionChanged',
-					params: session,
-				});
-				this.state = 'connected';
-			}
 		} else {
 			this.state = 'loaded';
 		}
@@ -207,86 +189,27 @@ export class MultichainSDK extends MultichainCore {
 				if (typeof window !== 'undefined') {
 					window.mmsdk = this;
 				}
+				logger(`SDK initialized`);
 			}
 		} catch (error) {
-			debugger;
 			logger('MetaMaskSDK error during initialization', error);
 		}
 	}
 
-	async getCurrentSession(): Promise<SessionData | undefined> {
-		try {
-			//TODO: We should report to the multichain api team that when there's no extension installed
-			// getSession timeouts and should be just undefined
-			// Thats why we need this function, to compensate that
-			let validSession: SessionData | undefined;
-			const session = await this.getActiveSession();
-
-			if (Object.keys(session?.sessionScopes ?? {}).length > 0) {
-				validSession = session;
-			}
-			return validSession;
-		} catch (err) {
-			logger('MetaMaskSDK error during getCurrentSession', err);
-			return undefined;
-		}
-	}
-
-	/**
-	 * Once Connection to transport is successfull, we will fetch the
-	 */
-	private async onConnectionSuccess(params: ModalFactoryConnectOptions) {
-		try {
-			if (!this.transport.isConnected()) {
-				await this.transport.connect(params);
-			}
-
-			debugger;
-			this.state = 'connected';
-			this.__provider ??= getMultichainClient({ transport: this.transport });
-			const session = await this.getCurrentSession();
-
-			if (session) {
-				const currentScopes = Object.keys(session?.sessionScopes ?? {}) as Scope[];
-				const proposedScopes = params.scopes;
-				const isSameScopes = currentScopes.every((scope) => proposedScopes.includes(scope)) && proposedScopes.every((scope) => currentScopes.includes(scope));
-				if (isSameScopes) {
-					this.emit('wallet_sessionChanged', session);
-					return;
-				}
-				await this.transport.request({ method: 'wallet_revokeSession', params: session });
-			}
-
-			const { scopes, caipAccountIds } = params;
-			const optionalScopes = addValidAccounts(getOptionalScopes(scopes), getValidAccounts(caipAccountIds));
-			const sessionRequest: CreateSessionParams<RPCAPI> = { optionalScopes };
-			const newSessionRequest = await this.transport.request({ method: 'wallet_createSession', params: sessionRequest });
-			const newSession = newSessionRequest.result as SessionData;
-			this.options.transport?.onNotification?.({
-				method: 'wallet_sessionChanged',
-				params: newSession,
-			});
-			this.emit('wallet_sessionChanged', newSession);
-		} catch (err) {
-			logger('MetaMaskSDK error during onConnectionSuccess', err);
-			throw err;
-		} finally {
-			this.state = this.transport.isConnected() ? 'connected' : 'disconnected';
-		}
-	}
-
 	private async showInstallModal(desktopPreferred: boolean, scopes: Scope[], caipAccountIds: CaipAccountId[]) {
 		return new Promise<void>((resolve, reject) => {
 			this.dappClient.once('connected', () => {
+				logger(`DappClient connected on showInstallModal`);
 				this.options.ui.factory.unload();
 			});
 			// Use Connection Modal
 			this.options.ui.factory.renderInstallModal(
 				desktopPreferred,
 				async () => {
+					logger(`Creating session request for QRCode`);
 					return new Promise<ConnectionRequest>((resolveConnectionRequest) => {
-						debugger;
 						this.dappClient.on('session_request', (sessionRequest: SessionRequest) => {
+							logger(`Session request received on showInstallModal`);
 							resolveConnectionRequest({
 								sessionRequest,
 								metadata: {
@@ -312,12 +235,18 @@ export class MultichainSDK extends MultichainCore {
 					});
 				},
 				async (error?: Error) => {
+					logger(`Unmounting install modal on showInstallModal`);
 					this.options.ui.factory.modal?.unmount();
 					if (!error) {
-						this.storage.setTransport(TransportType.MPW);
-						this.onConnectionSuccess({ scopes, caipAccountIds }).then(resolve).catch(reject);
+						await this.storage.setTransport(TransportType.MPW);
+						logger(`Setting transport to MPW on showInstallModal`);
+						this.__provider = getMultichainClient({ transport: this.transport });
+						this.state = 'connected';
+						resolve();
 					} else {
+						logger(`Setting state to disconnected on showInstallModal`);
 						this.state = 'disconnected';
+						await this.storage.removeTransport();
 						reject(error);
 					}
 				},
@@ -335,6 +264,10 @@ export class MultichainSDK extends MultichainCore {
 	}
 
 	private async setupMWP() {
+		if (this.__transport instanceof MWPTransport) {
+			return;
+		}
+		//Only setup MWP if it is not already mwp
 		const { adapter: kvstore } = this.options.storage;
 		const dappClient = await this.createDappClient();
 		this.__dappClient = dappClient;
@@ -371,13 +304,13 @@ export class MultichainSDK extends MultichainCore {
 		}
 	}
 
-	private async extensionConnect(scopes: Scope[], caipAccountIds: CaipAccountId[]) {
+	private async extensionConnect() {
 		this.state = 'connecting';
 		await this.storage.setTransport(TransportType.Browser);
 		const transport = getDefaultTransport();
 		this.listener = transport.onNotification(this.onTransportNotification.bind(this));
 		this.__transport = transport;
-		return this.onConnectionSuccess({ scopes, caipAccountIds });
+		return Promise.resolve();
 	}
 
 	private async deeplinkConnect(scopes: Scope[], caipAccountIds: CaipAccountId[]) {
@@ -417,7 +350,6 @@ export class MultichainSDK extends MultichainCore {
 					this.openDeeplink(deeplink, universalLink);
 				}
 			});
-			debugger;
 			this.state = 'connecting';
 			this.transport.connect({ scopes, caipAccountIds }).catch(reject);
 		});
@@ -432,14 +364,19 @@ export class MultichainSDK extends MultichainCore {
 		const isWeb = platformType === PlatformType.MetaMaskMobileWebview || platformType === PlatformType.DesktopWeb;
 		const { preferExtension = true, preferDesktop = false, headless: _headless = false } = ui;
 
-		if (this.__transport?.isConnected()) {
-			//If transport was loaded by sdk init, re-use session
-			return this.onConnectionSuccess({ scopes, caipAccountIds });
+		if (this.transport?.isConnected()) {
+			if (!(this.transport instanceof MWPTransport)) {
+				logger(`Transport already connected`);
+				return Promise.resolve();
+			}
+			logger(`MWP Transport already connected, reconnecting`);
+			return this.transport.connect({ scopes, caipAccountIds });
 		}
 
 		if (isWeb && hasExtension() && preferExtension) {
+			logger(`Metamask extension is available, connecting to extension`);
 			//If metamask extension is available, connect to it
-			return this.extensionConnect(scopes, caipAccountIds);
+			return this.extensionConnect();
 		}
 
 		// Connection will now be InstallModal + QRCodes or Deeplinks, both require mwp
@@ -455,10 +392,12 @@ export class MultichainSDK extends MultichainCore {
 
 		const secure = isSecure();
 		if (secure && !isDesktopPreferred) {
+			logger(`Desktop is not preferred option, using deeplinks`);
 			// Desktop is not preferred option, so we use deeplinks (mobile web)
 			return this.deeplinkConnect(scopes, caipAccountIds);
 		}
 
+		logger(`Showing install modal`);
 		// Show install modal for RN, Web + Node
 		return this.showInstallModal(isDesktopPreferred, scopes, caipAccountIds);
 	}
@@ -495,13 +434,12 @@ export class MultichainSDK extends MultichainCore {
 		const secure = isSecure();
 
 		if (secure && !preferDesktop) {
-			const response = client.invokeMethod(request);
 			if (this.options.mobile?.preferredOpenLink) {
 				this.options.mobile.preferredOpenLink(METAMASK_DEEPLINK_BASE, '_self');
 			} else {
 				this.openDeeplink(METAMASK_DEEPLINK_BASE, METAMASK_CONNECT_BASE_URL);
 			}
-			return response;
+			return client.invokeMethod(request);
 		} else {
 			return client.invokeMethod(request);
 		}