@portal-hq/web 3.4.2-beta.2 → 3.4.2

package/src/mpc/index.test.ts

@@ -26,6 +26,21 @@ import {
   mockSimulationResult,
   mockTransactionToEvaluate,
   mockTransactionToSimulate,
+  mockYieldXyzGetYieldsRequest,
+  mockYieldXyzGetYieldsResponse,
+  mockYieldXyzEnterRequest,
+  mockYieldXyzEnterResponse,
+  mockYieldXyzExitRequest,
+  mockYieldXyzExitResponse,
+  mockYieldXyzGetBalancesRequest,
+  mockYieldXyzGetBalancesResponse,
+  mockYieldXyzGetHistoricalActionsRequest,
+  mockYieldXyzGetHistoricalActionsResponse,
+  mockYieldXyzManageYieldRequest,
+  mockYieldXyzManageYieldResponse,
+  mockYieldXyzTrackTransactionRequest,
+  mockYieldXyzTrackTransactionResponse,
+  mockYieldXyzGetTransactionResponse,
 } from '../__mocks/constants'
 import portalMock from '../__mocks/portal/portal'
 import { PortalMpcError } from './errors'
@@ -243,6 +258,28 @@ describe('Mpc', () => {
           done()
         })
     })
+
+    it('should error out if backupMethod is invalid', (done) => {
+      mpc
+        .backup({
+          backupMethod: 'INVALID_METHOD' as any,
+          backupConfigs: {},
+          host: 'web.portalhq.io',
+          mpcVersion: 'v6',
+          featureFlags: {},
+        })
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(Error)
+          expect(e.message).toEqual(
+            'Invalid backup method: INVALID_METHOD. Valid methods are: GDRIVE, PASSWORD, PASSKEY, UNKNOWN',
+          )
+          done()
+        })
+    })
   })
 
   describe('clearLocalWallet', () => {
@@ -1988,4 +2025,612 @@ describe('Mpc', () => {
         })
     })
   })
+
+  describe('getYieldXyzYields', () => {
+    const args = mockYieldXyzGetYieldsRequest
+    const res = mockYieldXyzGetYieldsResponse
+
+    it('should successfully return the yields', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:yieldxyz:discover')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:discoverResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getYieldXyzYields(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:yieldxyz:discover')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:discoverError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getYieldXyzYields(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('enterYieldXyzYield', () => {
+    const args = mockYieldXyzEnterRequest
+    const res = mockYieldXyzEnterResponse
+
+    it('should successfully enter the yield', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:yieldxyz:enter')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:enterResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .enterYieldXyzYield(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:yieldxyz:enter')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:enterError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .enterYieldXyzYield(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('exitYieldXyzYield', () => {
+    const args = mockYieldXyzExitRequest
+    const res = mockYieldXyzExitResponse
+
+    it('should successfully exit the yield', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:yieldxyz:exit')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:exitResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .exitYieldXyzYield(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:yieldxyz:exit')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:exitError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .exitYieldXyzYield(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('getYieldXyzBalances', () => {
+    const args = mockYieldXyzGetBalancesRequest
+    const res = mockYieldXyzGetBalancesResponse
+
+    it('should successfully return the balances', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:yieldxyz:getBalances')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:getBalancesResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getYieldXyzBalances(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:yieldxyz:getBalances')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:getBalancesError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getYieldXyzBalances(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('getYieldXyzHistoricalActions', () => {
+    const args = mockYieldXyzGetHistoricalActionsRequest
+    const res = mockYieldXyzGetHistoricalActionsResponse
+
+    it('should successfully return the historical actions', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:yieldxyz:getHistoricalActions')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:getHistoricalActionsResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getYieldXyzHistoricalActions(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:yieldxyz:getHistoricalActions')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:getHistoricalActionsError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getYieldXyzHistoricalActions(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('manageYieldXyzYield', () => {
+    const args = mockYieldXyzManageYieldRequest
+    const res = mockYieldXyzManageYieldResponse
+
+    it('should successfully manage the yield', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:yieldxyz:manage')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:manageYieldResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .manageYieldXyzYield(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:yieldxyz:manage')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:manageYieldError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .manageYieldXyzYield(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('trackYieldXyzTransaction', () => {
+    const args = mockYieldXyzTrackTransactionRequest
+    const res = mockYieldXyzTrackTransactionResponse
+
+    it('should successfully track the transaction', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:yieldxyz:track')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:trackResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .trackYieldXyzTransaction(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:yieldxyz:track')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:trackError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .trackYieldXyzTransaction(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('getYieldXyzTransaction', () => {
+    const args = 'test-tx-id'
+    const res = mockYieldXyzGetTransactionResponse
+
+    it('should successfully return the transaction', (done) => {
+      jest
+        .spyOn(mpc.iframe?.contentWindow!, 'postMessage')
+        .mockImplementation((message: any, origin?) => {
+          const { type, data } = message
+
+          expect(type).toEqual('portal:yieldxyz:getTransaction')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:getTransactionResult',
+                data: res,
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getYieldXyzTransaction(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:yieldxyz:getTransaction')
+          expect(data).toEqual(args)
+          expect(origin).toEqual(mockHostOrigin)
+
+          window.dispatchEvent(
+            new MessageEvent('message', {
+              origin: mockHostOrigin,
+              data: {
+                type: 'portal:yieldxyz:getTransactionError',
+                data: {
+                  code: 1,
+                  message: 'test',
+                },
+              },
+            }),
+          )
+        })
+
+      mpc
+        .getYieldXyzTransaction(args)
+        .then(() => {
+          expect(0).toEqual(1)
+          done()
+        })
+        .catch((e) => {
+          expect(e).toBeInstanceOf(PortalMpcError)
+          expect(e.message).toEqual('test')
+          expect(e.code).toEqual(1)
+          done()
+        })
+    })
+  })
 })