@portal-hq/web 3.5.2 → 3.6.0-alpha

package/src/mpc/index.test.ts

@@ -41,6 +41,14 @@ import {
   mockYieldXyzTrackTransactionRequest,
   mockYieldXyzTrackTransactionResponse,
   mockYieldXyzGetTransactionResponse,
+  mockLifiGetRoutesRequest,
+  mockLifiGetRoutesResponse,
+  mockLifiGetQuoteRequest,
+  mockLifiGetQuoteResponse,
+  mockLifiGetStatusRequest,
+  mockLifiGetStatusResponse,
+  mockLifiGetRouteStepRequest,
+  mockLifiGetRouteStepResponse,
 } from '../__mocks/constants'
 import portalMock from '../__mocks/portal/portal'
 import { PortalMpcError } from './errors'
@@ -2633,4 +2641,308 @@ describe('Mpc', () => {
         })
     })
   })
+
+  describe('getLifiRoutes', () => {
+    const args = mockLifiGetRoutesRequest
+    const res = mockLifiGetRoutesResponse
+
+    it('should successfully return the routes', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:lifi:getRoutes')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:lifi:getRoutesResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getLifiRoutes(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:lifi:getRoutes')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:lifi:getRoutesError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getLifiRoutes(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('getLifiQuote', () => {
+    const args = mockLifiGetQuoteRequest
+    const res = mockLifiGetQuoteResponse
+
+    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:lifi:getQuote')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:lifi:getQuoteResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getLifiQuote(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:lifi:getQuote')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:lifi:getQuoteError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getLifiQuote(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('getLifiStatus', () => {
+    const args = mockLifiGetStatusRequest
+    const res = mockLifiGetStatusResponse
+
+    it('should successfully return the status', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:lifi:getStatus')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:lifi:getStatusResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getLifiStatus(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:lifi:getStatus')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:lifi:getStatusError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getLifiStatus(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('getLifiRouteStep', () => {
+    const args = mockLifiGetRouteStepRequest
+    const res = mockLifiGetRouteStepResponse
+
+    it('should successfully return the route step', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:lifi:getRouteStep')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:lifi:getRouteStepResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getLifiRouteStep(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:lifi:getRouteStep')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:lifi:getRouteStepError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getLifiRouteStep(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

@@ -57,8 +57,18 @@ import {
   YieldXyzTrackTransactionRequest,
   YieldXyzTrackTransactionResponse,
 } from '../../yieldxyz-types'
-
-const WEB_SDK_VERSION = '3.5.2'
+import {
+  LifiQuoteRequest,
+  LifiQuoteResponse,
+  LifiRoutesRequest,
+  LifiRoutesResponse,
+  LifiStatusRequest,
+  LifiStatusResponse,
+  LifiStepTransactionRequest,
+  LifiStepTransactionResponse,
+} from '../../lifi-types'
+
+const WEB_SDK_VERSION = '3.6.0-alpha'
 
 class Mpc {
   public iframe?: HTMLIFrameElement
@@ -1296,6 +1306,50 @@ class Mpc {
     })
   }
 
+  public async getLifiRoutes(
+    data: LifiRoutesRequest,
+  ): Promise<LifiRoutesResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:lifi:getRoutes',
+      errorMessage: 'portal:lifi:getRoutesError',
+      resultMessage: 'portal:lifi:getRoutesResult',
+      data,
+    })
+  }
+
+  public async getLifiQuote(
+    data: LifiQuoteRequest,
+  ): Promise<LifiQuoteResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:lifi:getQuote',
+      errorMessage: 'portal:lifi:getQuoteError',
+      resultMessage: 'portal:lifi:getQuoteResult',
+      data,
+    })
+  }
+
+  public async getLifiStatus(
+    data: LifiStatusRequest,
+  ): Promise<LifiStatusResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:lifi:getStatus',
+      errorMessage: 'portal:lifi:getStatusError',
+      resultMessage: 'portal:lifi:getStatusResult',
+      data,
+    })
+  }
+
+  public async getLifiRouteStep(
+    data: LifiStepTransactionRequest,
+  ): Promise<LifiStepTransactionResponse> {
+    return this.handleRequestToIframeAndPost({
+      methodMessage: 'portal:lifi:getRouteStep',
+      errorMessage: 'portal:lifi:getRouteStepError',
+      resultMessage: 'portal:lifi:getRouteStepResult',
+      data,
+    })
+  }
+
   /***************************
    * Private Methods
    ***************************/

package/tsconfig.json

@@ -19,6 +19,6 @@
     "types": ["jest"]
   },
   "exclude": ["lib", "**/node_modules", "**/jest.config.ts"],
-  "files": ["types.d.ts", "yieldxyz-types.d.ts"],
+  "files": ["types.d.ts", "yieldxyz-types.d.ts", "lifi-types.d.ts"],
   "include": ["**/*.ts", "**/*.tsx"]
 }

package/types.d.ts

@@ -404,7 +404,7 @@ export interface PortalApiOptions {
 
 export interface PortalError {
   code: number
-  message: string
+  message?: string
 }
 
 export interface PortalOptions {