@portal-hq/web 3.8.0 → 3.9.0

package/src/mpc/index.test.ts

@@ -70,6 +70,16 @@ import {
   mockScanTokenResponse,
   mockScanUrlRequest,
   mockScanUrlResponse,
+  mockBlockaidScanEvmTxRequest,
+  mockBlockaidScanEvmTxResponse,
+  mockBlockaidScanSolanaTxRequest,
+  mockBlockaidScanSolanaTxResponse,
+  mockBlockaidScanAddressRequest,
+  mockBlockaidScanAddressResponse,
+  mockBlockaidScanTokensRequest,
+  mockBlockaidScanTokensResponse,
+  mockBlockaidScanUrlRequest,
+  mockBlockaidScanUrlResponse,
 } from '../__mocks/constants'
 import portalMock from '../__mocks/portal/portal'
 import { PortalMpcError } from './errors'
@@ -3882,4 +3892,388 @@ describe('Mpc', () => {
         })
     })
   })
+
+  /*******************************
+   * Blockaid Security Methods Tests
+   *******************************/
+
+  describe('blockaidScanEvmTx', () => {
+    const args = mockBlockaidScanEvmTxRequest
+    const res = mockBlockaidScanEvmTxResponse
+
+    it('should successfully scan EVM transaction with Blockaid', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:blockaid:scanEvmTx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanEvmTxResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanEvmTx(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:blockaid:scanEvmTx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanEvmTxError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanEvmTx(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('blockaidScanSolanaTx', () => {
+    const args = mockBlockaidScanSolanaTxRequest
+    const res = mockBlockaidScanSolanaTxResponse
+
+    it('should successfully scan Solana transaction with Blockaid', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:blockaid:scanSolanaTx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanSolanaTxResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanSolanaTx(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:blockaid:scanSolanaTx')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanSolanaTxError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanSolanaTx(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('blockaidScanAddress', () => {
+    const args = mockBlockaidScanAddressRequest
+    const res = mockBlockaidScanAddressResponse
+
+    it('should successfully scan address with Blockaid', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:blockaid:scanAddress')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanAddressResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanAddress(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:blockaid:scanAddress')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanAddressError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanAddress(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('blockaidScanTokens', () => {
+    const args = mockBlockaidScanTokensRequest
+    const res = mockBlockaidScanTokensResponse
+
+    it('should successfully scan tokens with Blockaid', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:blockaid:scanTokens')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanTokensResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanTokens(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:blockaid:scanTokens')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanTokensError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanTokens(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('blockaidScanUrl', () => {
+    const args = mockBlockaidScanUrlRequest
+    const res = mockBlockaidScanUrlResponse
+
+    it('should successfully scan URL with Blockaid', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:blockaid:scanUrl')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanUrlResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanUrl(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:blockaid:scanUrl')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:blockaid:scanUrlError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .blockaidScanUrl(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
 })

package/src/mpc/index.ts

@@ -83,10 +83,20 @@ import {
   ScanTokensResponse,
   ScanUrlRequest,
   ScanUrlResponse,
+  BlockaidScanEvmTxRequest,
+  BlockaidScanEvmTxResponse,
+  BlockaidScanSolanaTxRequest,
+  BlockaidScanSolanaTxResponse,
+  BlockaidAddressScanRequest,
+  BlockaidAddressScanResponse,
+  BlockaidBulkTokenScanRequest,
+  BlockaidBulkTokenScanResponse,
+  BlockaidSiteScanRequest,
+  BlockaidSiteScanResponse,
 } from '../shared/types'
 import { ScreenAddressApiResponse, ScreenAddressRequestOptions } from '../../hypernative'
 
-const WEB_SDK_VERSION = '3.8.0'
+const WEB_SDK_VERSION = '3.9.0'
 
 class Mpc {
   public iframe?: HTMLIFrameElement
@@ -716,6 +726,65 @@ class Mpc {
     })
   }
 
+  /*******************************
+   * Blockaid Security Methods
+   *******************************/
+
+  public async blockaidScanEvmTx(
+    data: BlockaidScanEvmTxRequest,
+  ): Promise<BlockaidScanEvmTxResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:blockaid:scanEvmTx',
+      errorMessage: 'portal:blockaid:scanEvmTxError',
+      resultMessage: 'portal:blockaid:scanEvmTxResult',
+      data,
+    })
+  }
+
+  public async blockaidScanSolanaTx(
+    data: BlockaidScanSolanaTxRequest,
+  ): Promise<BlockaidScanSolanaTxResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:blockaid:scanSolanaTx',
+      errorMessage: 'portal:blockaid:scanSolanaTxError',
+      resultMessage: 'portal:blockaid:scanSolanaTxResult',
+      data,
+    })
+  }
+
+  public async blockaidScanAddress(
+    data: BlockaidAddressScanRequest,
+  ): Promise<BlockaidAddressScanResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:blockaid:scanAddress',
+      errorMessage: 'portal:blockaid:scanAddressError',
+      resultMessage: 'portal:blockaid:scanAddressResult',
+      data,
+    })
+  }
+
+  public async blockaidScanTokens(
+    data: BlockaidBulkTokenScanRequest,
+  ): Promise<BlockaidBulkTokenScanResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:blockaid:scanTokens',
+      errorMessage: 'portal:blockaid:scanTokensError',
+      resultMessage: 'portal:blockaid:scanTokensResult',
+      data,
+    })
+  }
+
+  public async blockaidScanUrl(
+    data: BlockaidSiteScanRequest,
+  ): Promise<BlockaidSiteScanResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:blockaid:scanUrl',
+      errorMessage: 'portal:blockaid:scanUrlError',
+      resultMessage: 'portal:blockaid:scanUrlResult',
+      data,
+    })
+  }
+
   /***************************
    * Private Methods
    ***************************/