@portal-hq/web 3.7.0 → 3.8.0

package/src/mpc/index.ts

@@ -56,8 +56,6 @@ import {
   YieldXyzManageYieldResponse,
   YieldXyzTrackTransactionRequest,
   YieldXyzTrackTransactionResponse,
-} from '../../yieldxyz-types'
-import {
   LifiQuoteRequest,
   LifiQuoteResponse,
   LifiRoutesRequest,
@@ -66,8 +64,6 @@ import {
   LifiStatusResponse,
   LifiStepTransactionRequest,
   LifiStepTransactionResponse,
-} from '../../lifi-types'
-import {
   ZeroExOptions,
   ZeroExPriceRequest,
   ZeroExPriceResponse,
@@ -75,9 +71,6 @@ import {
   ZeroExQuoteResponse,
   ZeroExSourcesRequest,
   ZeroExSourcesResponse,
-} from '../../zero-x'
-import {
-  ScreenAddressApiResponse,
   ScanEVMRequest,
   ScanEVMResponse,
   ScanEip712Request,
@@ -90,10 +83,10 @@ import {
   ScanTokensResponse,
   ScanUrlRequest,
   ScanUrlResponse,
-  ScreenAddressRequestOptions,
-} from '../../hypernative'
+} from '../shared/types'
+import { ScreenAddressApiResponse, ScreenAddressRequestOptions } from '../../hypernative'
 
-const WEB_SDK_VERSION = '3.7.0'
+const WEB_SDK_VERSION = '3.8.0'
 
 class Mpc {
   public iframe?: HTMLIFrameElement
@@ -129,108 +122,44 @@ class Mpc {
       // Noop
     },
   ): Promise<BackupResponse> {
-    const message = {
-      type: 'portal:wasm:backup',
-      data,
-    }
-
     // validates password config for password backup
     this.validateBackupConfig(data)
 
-    return new Promise((resolve, reject) => {
-      // Create a function to be bound when backup is triggered
-      const handleBackup = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:backupError') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleBackup)
-          window.removeEventListener('message', handleProgress)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:wasm:backupResult') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleBackup)
-          window.removeEventListener('message', handleProgress)
-
-          const resultData = result as Record<string, unknown>
-          const backupIds = Array.isArray(resultData.backupIds)
-            ? (resultData.backupIds as string[])
-            : []
-          const storageCallback = async () => {
-            await this.setBackupStatus('STORED_CLIENT_BACKUP_SHARE', backupIds)
-          }
-
-          // Resolve the promise with the result
-          resolve({
-            cipherText: resultData.cipherText as string,
-            encryptionKey:
-              typeof resultData.encryptionKey === 'string'
-                ? (resultData.encryptionKey as string)
-                : undefined,
-            storageCallback,
-          })
-        }
-      }
-
-      const handleProgress = (message: MessageEvent<WorkerResult>) => {
-        const { type, data: status } = message.data
-        const { origin } = message
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:wasm:backup',
+      errorMessage: 'portal:wasm:backupError',
+      resultMessage: 'portal:wasm:backupResult',
+      data,
+      progressMessage: 'portal:wasm:backupProgress',
+      progressCallback: progress,
+      mapReturnValue: (result: Record<string, unknown>) => {
+        const resultData = result as Record<string, unknown>
+        const backupIds = Array.isArray(resultData.backupIds)
+          ? (resultData.backupIds as string[])
+          : []
+        const storageCallback = async () => {
+          await this.setBackupStatus('STORED_CLIENT_BACKUP_SHARE', backupIds)
         }
 
-        if (type === 'portal:wasm:backupProgress') {
-          void progress(status as MpcStatus)
+        return {
+          cipherText: result.cipherText as string,
+          encryptionKey:
+            typeof resultData.encryptionKey === 'string'
+              ? (resultData.encryptionKey as string)
+              : undefined,
+          storageCallback,
         }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleBackup)
-      window.addEventListener('message', handleProgress)
-
-      // Send the request to the iframe
-      this.postMessage(message)
+      },
     })
   }
 
   public clearLocalWallet(): Promise<boolean> {
-    return new Promise((resolve) => {
-      const handleClearLocalWallet = (event: MessageEvent<WorkerResult>) => {
-        const { type } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:destroyResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleClearLocalWallet)
-
-          // Resolve the promise with the result
-          resolve(true)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleClearLocalWallet)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:destroy',
-        data: {},
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:destroy',
+      errorMessage: 'portal:destroyError', // This message is not used in the iframe
+      resultMessage: 'portal:destroyResult',
+      data: {},
+      mapReturnValue: () => true,
     })
   }
 
@@ -240,95 +169,22 @@ class Mpc {
       // Noop
     },
   ): Promise<string> {
-    const message = {
-      type: 'portal:wasm:generate',
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:wasm:generate',
+      errorMessage: 'portal:wasm:generateError',
+      resultMessage: 'portal:wasm:generateResult',
       data,
-    }
-
-    return new Promise((resolve, reject) => {
-      // Create a function to be bound when generate is triggered
-      const handleGenerate = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        // Handle errors
-        if (type === 'portal:wasm:generateError') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleGenerate)
-          window.removeEventListener('message', handleProgress)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:wasm:generateResult') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleGenerate)
-          window.removeEventListener('message', handleProgress)
-
-          // Resolve the promise with the result
-          resolve(result as string)
-        }
-      }
-
-      const handleProgress = (message: MessageEvent<WorkerResult>) => {
-        const { type, data: status } = message.data
-        const { origin } = message
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:generateProgress') {
-          void progress(status as MpcStatus)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGenerate)
-      window.addEventListener('message', handleProgress)
-
-      // Send the request to the iframe
-      this.postMessage(message)
+      progressMessage: 'portal:wasm:generateProgress',
+      progressCallback: progress,
     })
   }
 
   public async getAddress(): Promise<string> {
-    const message = {
-      type: 'portal:address',
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:address',
+      errorMessage: 'portal:addressError', // This message is not used in the iframe
+      resultMessage: 'portal:addressResult',
       data: {},
-    }
-
-    return new Promise((resolve) => {
-      // Create a function to be bound when getAddress is triggered
-      const handleGetAddress = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        // Check that the message is the one we're looking for
-        if (type === 'portal:addressResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetAddress)
-
-          // Resolve the promise with the result
-          resolve(result as string)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetAddress)
-
-      // Send the request to the iframe
-      this.postMessage(message)
     })
   }
 
@@ -338,160 +194,45 @@ class Mpc {
       // Noop
     },
   ): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const handleRecover = (message: MessageEvent<WorkerResult>) => {
-        const { type, data } = message.data
-        const { origin } = message
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:recoverError') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleRecover)
-          window.removeEventListener('message', handleProgress)
-
-          reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:wasm:recoverResult') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleRecover)
-          window.removeEventListener('message', handleProgress)
-
-          resolve(data as string)
-        }
-      }
-
-      const handleProgress = (message: MessageEvent<WorkerResult>) => {
-        const { type, data: status } = message.data
-        const { origin } = message
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:recoverProgress') {
-          void progress(status as MpcStatus)
-        }
-      }
-
-      window.addEventListener('message', handleRecover)
-      window.addEventListener('message', handleProgress)
-
-      this.postMessage({
-        type: 'portal:wasm:recover',
-        data,
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:wasm:recover',
+      errorMessage: 'portal:wasm:recoverError',
+      resultMessage: 'portal:wasm:recoverResult',
+      data,
+      progressMessage: 'portal:wasm:recoverProgress',
+      progressCallback: progress,
     })
   }
 
   public async eject(data: EjectArgs): Promise<EjectResult> {
-    return new Promise((resolve, reject) => {
-      const handleEject = (message: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = message.data
-        const { origin } = message
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:ejectError') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleEject)
-
-          reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:wasm:ejectResult') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleEject)
-
-          resolve(result as EjectResult)
-        }
-      }
-
-      window.addEventListener('message', handleEject)
-
-      this.postMessage({
-        type: 'portal:wasm:eject',
-        data,
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:wasm:eject',
+      errorMessage: 'portal:wasm:ejectError',
+      resultMessage: 'portal:wasm:ejectResult',
+      data,
     })
   }
 
   public async ejectPrivateKeys(
     data: EjectPrivateKeysArgs,
   ): Promise<EjectPrivateKeysResult> {
-    return new Promise((resolve, reject) => {
-      const handleEject = (message: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = message.data
-        const { origin } = message
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:ejectPrivateKeysError') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleEject)
-
-          reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:wasm:ejectPrivateKeysResult') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleEject)
-
-          resolve(result as EjectPrivateKeysResult)
-        }
-      }
-
-      window.addEventListener('message', handleEject)
-
-      this.postMessage({
-        type: 'portal:wasm:ejectPrivateKeys',
-        data,
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:wasm:ejectPrivateKeys',
+      errorMessage: 'portal:wasm:ejectPrivateKeysError',
+      resultMessage: 'portal:wasm:ejectPrivateKeysResult',
+      data,
     })
   }
 
   public async rawSign(curve: PortalCurve, param: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const handleRawSign = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:mpc:rawSignError') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleRawSign)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:mpc:rawSignResult') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleRawSign)
-
-          // Resolve the promise with the result
-          resolve(result as string)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleRawSign)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:mpc:rawSign',
-        data: {
-          curve,
-          param,
-        },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:mpc:rawSign',
+      errorMessage: 'portal:mpc:rawSignError',
+      resultMessage: 'portal:mpc:rawSignResult',
+      data: {
+        curve,
+        param,
+      },
     })
   }
 
@@ -501,94 +242,22 @@ class Mpc {
       // Noop
     },
   ): Promise<string> {
-    return new Promise((resolve, reject) => {
-      // Create a function to be bound when sign is triggered
-      const handleSign = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:signError') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleSign)
-          window.removeEventListener('message', handleProgress)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:wasm:signResult') {
-          // Remove the event listeners
-          window.removeEventListener('message', handleSign)
-          window.removeEventListener('message', handleProgress)
-
-          // Resolve the promise with the result
-          resolve(result as string)
-        }
-      }
-
-      const handleProgress = (message: MessageEvent<WorkerResult>) => {
-        const { type, data: status } = message.data
-        const { origin } = message
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:signProgress') {
-          void progress(status as MpcStatus)
-        }
-      }
-
-      // Bind the functions to the message event
-      window.addEventListener('message', handleSign)
-      window.addEventListener('message', handleProgress)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:wasm:sign',
-        data,
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:wasm:sign',
+      errorMessage: 'portal:wasm:signError',
+      resultMessage: 'portal:wasm:signResult',
+      data,
+      progressMessage: 'portal:wasm:signProgress',
+      progressCallback: progress,
     })
   }
 
   public async checkSharesOnDevice(): Promise<SharesOnDeviceResponse> {
-    return new Promise((resolve, reject) => {
-      const handleCheckSharesOnDevice = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:checkSharesOnDeviceError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleCheckSharesOnDevice)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:checkSharesOnDeviceResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleCheckSharesOnDevice)
-
-          // Resolve the promise with the result
-          resolve(data as SharesOnDeviceResponse)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleCheckSharesOnDevice)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:checkSharesOnDevice',
-        data: {},
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:checkSharesOnDevice',
+      errorMessage: 'portal:checkSharesOnDeviceError',
+      resultMessage: 'portal:checkSharesOnDeviceResult',
+      data: {},
     })
   }
 
@@ -597,39 +266,11 @@ class Mpc {
    *******************************/
 
   public async getBalances(chainId?: string): Promise<Balance[]> {
-    return new Promise((resolve, reject) => {
-      const handleGetBalances = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:getBalancesError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetBalances)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:getBalancesResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetBalances)
-
-          // Resolve the promise with the result
-          resolve(data as Balance[])
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetBalances)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:getBalances',
-        data: { chainId },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:getBalances',
+      errorMessage: 'portal:getBalancesError',
+      resultMessage: 'portal:getBalancesResult',
+      data: { chainId },
     })
   }
 
@@ -637,190 +278,50 @@ class Mpc {
     chainId: string,
     params: FundParams,
   ): Promise<FundResponse> {
-    return new Promise((resolve, reject) => {
-      const handleFund = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // Ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:fundError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleFund)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:fundResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleFund)
-
-          // Resolve the promise with the result
-          resolve(data as FundResponse)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleFund)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:fund',
-        data: { chainId, params },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:fund',
+      errorMessage: 'portal:fundError',
+      resultMessage: 'portal:fundResult',
+      data: { chainId, params },
     })
   }
 
   public async getClient(): Promise<ClientResponse> {
-    return new Promise((resolve, reject) => {
-      const handleGetClient = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:getClientError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetClient)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:getClientResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetClient)
-
-          // Resolve the promise with the result
-          resolve(data as ClientResponse)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetClient)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:getClient',
-        data: {},
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:getClient',
+      errorMessage: 'portal:getClientError',
+      resultMessage: 'portal:getClientResult',
+      data: {},
     })
   }
 
   public async getNFTs(chainId?: string): Promise<NFT[]> {
-    return new Promise((resolve, reject) => {
-      const handleGetNFTs = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:getNFTsError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetNFTs)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:getNFTsResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetNFTs)
-
-          // Resolve the promise with the result
-          resolve(data as NFT[])
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetNFTs)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:getNFTs',
-        data: { chainId },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:getNFTs',
+      errorMessage: 'portal:getNFTsError',
+      resultMessage: 'portal:getNFTsResult',
+      data: { chainId },
     })
   }
 
   public async getNFTAssets(chainId: string): Promise<NFTAsset[]> {
-    return new Promise((resolve, reject) => {
-      const handleGetNFTAssets = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:getNFTAssetsError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetNFTAssets)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:getNFTAssetsResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetNFTAssets)
-
-          // Resolve the promise with the result
-          resolve(data as NFTAsset[])
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetNFTAssets)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:getNFTAssets',
-        data: { chainId },
-      })
-    })
-  }
-
-  public async getAssets(
-    chainId: string,
-    includeNfts = false,
-  ): Promise<GetAssetsResponse> {
-    return new Promise((resolve, reject) => {
-      const handleGetAssets = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:getAssetsError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetAssets)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:getAssetsResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetAssets)
-
-          // Resolve the promise with the result
-          resolve(data as GetAssetsResponse)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetAssets)
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:getNFTAssets',
+      errorMessage: 'portal:getNFTAssetsError',
+      resultMessage: 'portal:getNFTAssetsResult',
+      data: { chainId },
+    })
+  }
 
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:getAssets',
-        data: { chainId, includeNfts },
-      })
+  public async getAssets(
+    chainId: string,
+    includeNfts = false,
+  ): Promise<GetAssetsResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:getAssets',
+      errorMessage: 'portal:getAssetsError',
+      resultMessage: 'portal:getAssetsResult',
+      data: { chainId, includeNfts },
     })
   }
 
@@ -830,39 +331,11 @@ class Mpc {
     token: string,
     amount: string,
   ): Promise<BuiltTransaction> {
-    return new Promise((resolve, reject) => {
-      const handlebuildTransaction = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:buildTransactionError') {
-          // Remove the event listener
-          window.removeEventListener('message', handlebuildTransaction)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:buildTransactionResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handlebuildTransaction)
-
-          // Resolve the promise with the result
-          resolve(data as BuiltTransaction)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handlebuildTransaction)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:buildTransaction',
-        data: { chainId, to, token, amount },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:buildTransaction',
+      errorMessage: 'portal:buildTransactionError',
+      resultMessage: 'portal:buildTransactionResult',
+      data: { chainId, to, token, amount },
     })
   }
 
@@ -871,42 +344,15 @@ class Mpc {
     args: QuoteArgs,
     apiKey?: string,
   ): Promise<QuoteResponse> {
-    return new Promise((resolve, reject) => {
-      const handleGetQuote = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-        if (type === 'portal:swaps:getQuoteError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetQuote)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:swaps:getQuoteResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetQuote)
-
-          // Resolve the promise with the result
-          resolve(result as QuoteResponse)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetQuote)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:swaps:getQuote',
-        data: {
-          apiKey,
-          args,
-          chainId,
-        },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:swaps:getQuote',
+      errorMessage: 'portal:swaps:getQuoteError',
+      resultMessage: 'portal:swaps:getQuoteResult',
+      data: {
+        apiKey,
+        args,
+        chainId,
+      },
     })
   }
 
@@ -914,41 +360,14 @@ class Mpc {
     chainId: string,
     apiKey?: string,
   ): Promise<Record<string, string>> {
-    return new Promise((resolve, reject) => {
-      const handleGetSources = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-        if (type === 'portal:swaps:getSourcesError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetSources)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:swaps:getSourcesResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetSources)
-
-          // Resolve the promise with the result
-          resolve(result as Record<string, string>)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetSources)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:swaps:getSources',
-        data: {
-          apiKey,
-          chainId,
-        },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:swaps:getSources',
+      errorMessage: 'portal:swaps:getSourcesError',
+      resultMessage: 'portal:swaps:getSourcesResult',
+      data: {
+        apiKey,
+        chainId,
+      },
     })
   }
 
@@ -958,44 +377,16 @@ class Mpc {
     offset?: number,
     order?: GetTransactionsOrder,
   ): Promise<Transaction[]> {
-    return new Promise((resolve, reject) => {
-      const handleGetTransactions = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:getTransactionsError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetTransactions)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:getTransactionsResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetTransactions)
-
-          // Resolve the promise with the result
-          resolve(data as Transaction[])
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetTransactions)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:getTransactions',
-        data: {
-          chainId,
-          limit,
-          offset,
-          order,
-        },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:getTransactions',
+      errorMessage: 'portal:getTransactionsError',
+      resultMessage: 'portal:getTransactionsResult',
+      data: {
+        chainId,
+        limit,
+        offset,
+        order,
+      },
     })
   }
 
@@ -1003,41 +394,14 @@ class Mpc {
     status: string,
     backupIds: string[],
   ): Promise<boolean> {
-    return new Promise((resolve, reject) => {
-      const handleSetBackupStatus = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:api:setBackupStatusError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleSetBackupStatus)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:api:setBackupStatusResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleSetBackupStatus)
-
-          // Resolve the promise with the result
-          return resolve(data as boolean)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleSetBackupStatus)
-
-      this.postMessage({
-        type: 'portal:api:setBackupStatus',
-        data: {
-          backupIds,
-          status,
-        },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:api:setBackupStatus',
+      errorMessage: 'portal:api:setBackupStatusError',
+      resultMessage: 'portal:api:setBackupStatusResult',
+      data: {
+        backupIds,
+        status,
+      },
     })
   }
 
@@ -1045,42 +409,14 @@ class Mpc {
     transaction: SimulateTransactionParam,
     chainId?: string,
   ): Promise<SimulatedTransaction> {
-    return new Promise((resolve, reject) => {
-      const handleSimulateTransaction = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:simulateTransactionError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleSimulateTransaction)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:simulateTransactionResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleSimulateTransaction)
-
-          // Resolve the promise with the result
-          resolve(data as SimulatedTransaction)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleSimulateTransaction)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:simulateTransaction',
-        data: {
-          chainId,
-          transaction,
-        },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:simulateTransaction',
+      errorMessage: 'portal:simulateTransactionError',
+      resultMessage: 'portal:simulateTransactionResult',
+      data: {
+        chainId,
+        transaction,
+      },
     })
   }
 
@@ -1089,43 +425,15 @@ class Mpc {
     transaction: EvaluateTransactionParam,
     operationType: EvaluateTransactionOperationType = 'all',
   ): Promise<EvaluatedTransaction> {
-    return new Promise((resolve, reject) => {
-      const handleEvaluateTransaction = (event: MessageEvent<WorkerResult>) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:evaluateTransactionError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleEvaluateTransaction)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:evaluateTransactionResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleEvaluateTransaction)
-
-          // Resolve the promise with the result
-          resolve(data as EvaluatedTransaction)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleEvaluateTransaction)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:evaluateTransaction',
-        data: {
-          chainId,
-          transaction,
-          operationType,
-        },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:evaluateTransaction',
+      errorMessage: 'portal:evaluateTransactionError',
+      resultMessage: 'portal:evaluateTransactionResult',
+      data: {
+        chainId,
+        transaction,
+        operationType,
+      },
     })
   }
 
@@ -1133,118 +441,33 @@ class Mpc {
     success: boolean,
     backupMethod: BackupMethods,
   ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const handleStoredClientBackupShare = (
-        event: MessageEvent<WorkerResult>,
-      ) => {
-        const { type, data } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:storedClientBackupShareError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleStoredClientBackupShare)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(data as PortalError))
-        } else if (type === 'portal:storedClientBackupShareResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleStoredClientBackupShare)
-
-          // Resolve the promise with the result
-          resolve()
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleStoredClientBackupShare)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:storedClientBackupShare',
-        data: {
-          success,
-          backupMethod,
-        },
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:storedClientBackupShare',
+      errorMessage: 'portal:storedClientBackupShareError',
+      resultMessage: 'portal:storedClientBackupShareResult',
+      data: {
+        success,
+        backupMethod,
+      },
+      mapReturnValue: () => undefined,
     })
   }
 
   public async formatShares(shares: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const handleFormatShares = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:formatSharesError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleFormatShares)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:wasm:formatSharesResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleFormatShares)
-
-          // Resolve the promise with the result
-          resolve(result as string)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleFormatShares)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:wasm:formatShares',
-        data: shares,
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:wasm:formatShares',
+      errorMessage: 'portal:wasm:formatSharesError',
+      resultMessage: 'portal:wasm:formatSharesResult',
+      data: shares,
     })
   }
 
   public async getCustodianIdClientIdHashes(data: any): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const handleGetHashes = (event: MessageEvent<WorkerResult>) => {
-        const { type, data: result } = event.data
-        const { origin } = event
-
-        // ignore any broadcast postMessages
-        if (origin !== this.getOrigin()) {
-          return
-        }
-
-        if (type === 'portal:wasm:getCustodianIdClientIdHashesError') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetHashes)
-
-          // Reject the promise with the error
-          return reject(new PortalMpcError(result as PortalError))
-        } else if (type === 'portal:wasm:getCustodianIdClientIdHashesResult') {
-          // Remove the event listener
-          window.removeEventListener('message', handleGetHashes)
-
-          // Resolve the promise with the result
-          resolve(result as string)
-        }
-      }
-
-      // Bind the function to the message event
-      window.addEventListener('message', handleGetHashes)
-
-      // Send the request to the iframe
-      this.postMessage({
-        type: 'portal:wasm:getCustodianIdClientIdHashes',
-        data,
-      })
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:wasm:getCustodianIdClientIdHashes',
+      errorMessage: 'portal:wasm:getCustodianIdClientIdHashesError',
+      resultMessage: 'portal:wasm:getCustodianIdClientIdHashesResult',
+      data,
     })
   }
 
@@ -1505,11 +728,17 @@ class Mpc {
     errorMessage,
     resultMessage,
     data,
+    progressMessage,
+    progressCallback,
+    mapReturnValue,
   }: {
     methodMessage: string
     errorMessage: string
     resultMessage: string
     data: any
+    progressMessage?: string
+    progressCallback?: (status: MpcStatus) => void
+    mapReturnValue?: (result: any) => T
   }): Promise<T> {
     return new Promise((resolve, reject) => {
       const handleRequest = (event: MessageEvent<WorkerResult>) => {
@@ -1532,7 +761,11 @@ class Mpc {
           window.removeEventListener('message', handleRequest)
 
           // Resolve the promise with the result
-          resolve(result as T)
+          resolve(mapReturnValue ? mapReturnValue(result) : (result as T))
+        }
+
+        if (type === progressMessage && progressCallback) {
+          void progressCallback(result as MpcStatus)
         }
       }
 
@@ -1706,8 +939,7 @@ class Mpc {
     const validBackupMethods = Object.values(BackupMethods)
     if (!validBackupMethods.includes(data.backupMethod)) {
       throw new Error(
-        `Invalid backup method: ${
-          data.backupMethod
+        `Invalid backup method: ${data.backupMethod
         }. Valid methods are: ${validBackupMethods.join(', ')}`,
       )
     }