@portal-hq/web 3.6.2-alpha → 3.7.0

package/src/mpc/index.test.ts

@@ -49,6 +49,27 @@ import {
   mockLifiGetStatusResponse,
   mockLifiGetRouteStepRequest,
   mockLifiGetRouteStepResponse,
+  mockZeroExQuoteV2Request,
+  mockZeroExQuoteV2Response,
+  mockZeroExSourcesV2Request,
+  mockZeroExSourcesV2Response,
+  mockZeroExPriceRequest,
+  mockZeroExPriceResponse,
+  mockZeroExOptions,
+  mockScanAddressesRequest,
+  mockScanAddressesResponse,
+  mockScanEVMTxRequest,
+  mockScanEVMTxResponse,
+  mockScanEip712TxRequest,
+  mockScanEip712TxResponse,
+  mockScanSolanaTxRequest,
+  mockScanSolanaTxResponse,
+  mockScanNftRequest,
+  mockScanNftResponse,
+  mockScanTokenRequest,
+  mockScanTokenResponse,
+  mockScanUrlRequest,
+  mockScanUrlResponse,
 } from '../__mocks/constants'
 import portalMock from '../__mocks/portal/portal'
 import { PortalMpcError } from './errors'
@@ -163,6 +184,60 @@ describe('Mpc', () => {
         })
     })
 
+    it('should include encryption key when iframe returns custom backup response', (done) => {
+      const setBackupStatusSpy = jest
+        .spyOn(mpc, 'setBackupStatus')
+        .mockResolvedValue(true as any)
+
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:wasm:backup')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:wasm:backupResult',
+                data: {
+                  cipherText: mockCipherText,
+                  encryptionKey: 'custom-backup-key',
+                  backupIds: mockBackupIds,
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .backup(args)
+        .then(async (res) => {
+          expect(res.cipherText).toEqual(mockCipherText)
+          expect(res.encryptionKey).toEqual('custom-backup-key')
+
+          await res.storageCallback()
+
+          expect(setBackupStatusSpy).toHaveBeenCalledTimes(1)
+          expect(setBackupStatusSpy).toHaveBeenCalledWith(
+            'STORED_CLIENT_BACKUP_SHARE',
+            mockBackupIds,
+          )
+          done()
+        })
+        .catch((e) => {
+          console.error(e)
+          expect(0).toEqual(1)
+          done()
+        })
+        .finally(() => {
+          setBackupStatusSpy.mockRestore()
+        })
+    })
+
     it('should error out if the iframe sends an error message', (done) => {
       jest
         .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
@@ -283,7 +358,7 @@ describe('Mpc', () => {
         .catch((e) => {
           expect(e).toBeInstanceOf(Error)
           expect(e.message).toEqual(
-            'Invalid backup method: INVALID_METHOD. Valid methods are: GDRIVE, PASSWORD, PASSKEY, UNKNOWN',
+            'Invalid backup method: INVALID_METHOD. Valid methods are: GDRIVE, PASSWORD, PASSKEY, CUSTOM, UNKNOWN',
           )
           done()
         })
@@ -1496,7 +1571,7 @@ describe('Mpc', () => {
         })
 
       mpc
-        .getQuote(mockApikey, mockQuoteArgs, 'eip155:1')
+        .getQuote('eip155:1', mockQuoteArgs, mockApikey)
         .then((data) => {
           expect(data).toEqual(res)
           done()
@@ -1536,7 +1611,7 @@ describe('Mpc', () => {
         })
 
       mpc
-        .getQuote(mockApikey, mockQuoteArgs, 'eip155:1')
+        .getQuote('eip155:1', mockQuoteArgs, mockApikey)
         .then(() => {
           expect(0).toEqual(1)
           done()
@@ -1575,7 +1650,7 @@ describe('Mpc', () => {
         })
 
       mpc
-        .getSources(mockApikey, 'eip155:1')
+        .getSources('eip155:1', mockApikey)
         .then((data) => {
           expect(data).toEqual(res)
           done()
@@ -1611,7 +1686,7 @@ describe('Mpc', () => {
         })
 
       mpc
-        .getSources(mockApikey, 'eip155:1')
+        .getSources('eip155:1', mockApikey)
         .then(() => {
           expect(0).toEqual(1)
           done()
@@ -1746,8 +1821,8 @@ describe('Mpc', () => {
         .catch((_) => {
           expect(0).toEqual(1)
           done()
-        })
-    })
+      })
+  })
 
     it('should error out if the iframe sends an error message', (done) => {
       jest
@@ -2945,4 +3020,866 @@ describe('Mpc', () => {
         })
     })
   })
+
+  describe('getSwapsQuoteV2', () => {
+    const args = mockZeroExQuoteV2Request
+    const options = mockZeroExOptions
+    const res = mockZeroExQuoteV2Response
+
+    it('should successfully return the quote', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getQuoteV2')
+          expect(data).toEqual({ ...args, options })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getQuoteV2Result',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsQuoteV2(args, options)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should successfully return the quote without options', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getQuoteV2')
+          expect(data).toEqual({ ...args, options: undefined })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getQuoteV2Result',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsQuoteV2(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getQuoteV2')
+          expect(data).toEqual({ ...args, options })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getQuoteV2Error',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsQuoteV2(args, options)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('getSwapsSourcesV2', () => {
+    const args = mockZeroExSourcesV2Request
+    const options = mockZeroExOptions
+    const res = mockZeroExSourcesV2Response
+
+    it('should successfully return the sources', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getSourcesV2')
+          expect(data).toEqual({ ...args, options })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getSourcesV2Result',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsSourcesV2(args, options)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should successfully return the sources without options', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getSourcesV2')
+          expect(data).toEqual({ ...args, options: undefined })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getSourcesV2Result',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsSourcesV2(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getSourcesV2')
+          expect(data).toEqual({ ...args, options })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getSourcesV2Error',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsSourcesV2(args, options)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('getSwapsPrice', () => {
+    const args = mockZeroExPriceRequest
+    const options = mockZeroExOptions
+    const res = mockZeroExPriceResponse
+
+    it('should successfully return the price', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getPrice')
+          expect(data).toEqual({ ...args, options })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getPriceResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsPrice(args, options)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should successfully return the price without options', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getPrice')
+          expect(data).toEqual({ ...args, options: undefined })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getPriceResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsPrice(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:swaps:getPrice')
+          expect(data).toEqual({ ...args, options })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:swaps:getPriceError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getSwapsPrice(args, options)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('scanAddresses', () => {
+    const args = mockScanAddressesRequest
+    const res = mockScanAddressesResponse
+
+    it('should successfully scan addresses', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanAddresses')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanAddressesResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanAddresses(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanAddresses')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanAddressesError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanAddresses(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('scanEVMTx', () => {
+    const args = mockScanEVMTxRequest
+    const res = mockScanEVMTxResponse
+
+    it('should successfully scan EIP-155 transaction', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanEVMTx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanEVMTxResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanEVMTx(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanEVMTx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanEVMTxError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanEVMTx(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('scanEip712Tx', () => {
+    const args = mockScanEip712TxRequest
+    const res = mockScanEip712TxResponse
+
+    it('should successfully scan EIP-712 transaction', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanEip712Tx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanEip712TxResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanEip712Tx(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanEip712Tx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanEip712TxError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanEip712Tx(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('scanSolanaTx', () => {
+    const args = mockScanSolanaTxRequest
+    const res = mockScanSolanaTxResponse
+
+    it('should successfully scan Solana transaction', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanSolanaTx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanSolanaTxResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanSolanaTx(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanSolanaTx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanSolanaTxError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanSolanaTx(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('scanNft', () => {
+    const args = mockScanNftRequest
+    const res = mockScanNftResponse
+
+    it('should successfully scan NFT', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanNfts')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanNftsResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanNFTs(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanNfts')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanNftsError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanNFTs(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('scanToken', () => {
+    const args = mockScanTokenRequest
+    const res = mockScanTokenResponse
+
+    it('should successfully scan token', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanTokens')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanTokensResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanTokens(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanTokens')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanTokensError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanTokens(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
+
+  describe('scanUrl', () => {
+    const args = mockScanUrlRequest
+    const res = mockScanUrlResponse
+
+    it('should successfully scan URL', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanUrl')
+          expect(data).toEqual({ url: args })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanUrlResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanUrl(args)
+        .then((data) => {
+          expect(data).toEqual(res)
+          done()
+        })
+        .catch((_) => {
+          expect(0).toEqual(1)
+          done()
+        })
+    })
+
+    it('should error out if the iframe sends an error message', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementationOnce((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:security:scanUrl')
+          expect(data).toEqual({ url: args })
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:security:scanUrlError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .scanUrl(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
 })