@portal-hq/web 3.4.1 → 3.5.0-alpha

package/lib/esm/integrations/yield/yieldxyz.test.js

@@ -0,0 +1,149 @@
+/**
+ * @jest-environment jsdom
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import YieldXyz from './yieldxyz';
+import Mpc from '../../mpc';
+import portalMock from '../../__mocks/portal/portal';
+import { mockHost, mockYieldXyzGetYieldsRequest, mockYieldXyzGetYieldsResponse, mockYieldXyzEnterRequest, mockYieldXyzEnterResponse, mockYieldXyzExitRequest, mockYieldXyzExitResponse, mockYieldXyzGetBalancesRequest, mockYieldXyzGetBalancesResponse, mockYieldXyzGetHistoricalActionsRequest, mockYieldXyzGetHistoricalActionsResponse, mockYieldXyzManageYieldRequest, mockYieldXyzManageYieldResponse, mockYieldXyzTrackTransactionRequest, mockYieldXyzTrackTransactionResponse, mockYieldXyzGetTransactionResponse, } from '../../__mocks/constants';
+describe('YieldXyz', () => {
+    let yieldXyz;
+    let mpc;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portalMock.host = mockHost;
+        mpc = new Mpc({
+            portal: portalMock,
+        });
+        yieldXyz = new YieldXyz({ mpc });
+    });
+    describe('discover', () => {
+        it('should call mpc.getYieldXyzYields with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getYieldXyzYields')
+                .mockResolvedValue(mockYieldXyzGetYieldsResponse);
+            const result = yield yieldXyz.discover(mockYieldXyzGetYieldsRequest);
+            expect(spy).toHaveBeenCalledWith(mockYieldXyzGetYieldsRequest);
+            expect(result).toEqual(mockYieldXyzGetYieldsResponse);
+        }));
+        it('should propagate errors from mpc.getYieldXyzYields', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'getYieldXyzYields').mockRejectedValue(error);
+            yield expect(yieldXyz.discover(mockYieldXyzGetYieldsRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('enter', () => {
+        it('should call mpc.enterYieldXyzYield with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'enterYieldXyzYield')
+                .mockResolvedValue(mockYieldXyzEnterResponse);
+            const result = yield yieldXyz.enter(mockYieldXyzEnterRequest);
+            expect(spy).toHaveBeenCalledWith(mockYieldXyzEnterRequest);
+            expect(result).toEqual(mockYieldXyzEnterResponse);
+        }));
+        it('should propagate errors from mpc.enterYieldXyzYield', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'enterYieldXyzYield').mockRejectedValue(error);
+            yield expect(yieldXyz.enter(mockYieldXyzEnterRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('exit', () => {
+        it('should call mpc.exitYieldXyzYield with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'exitYieldXyzYield')
+                .mockResolvedValue(mockYieldXyzExitResponse);
+            const result = yield yieldXyz.exit(mockYieldXyzExitRequest);
+            expect(spy).toHaveBeenCalledWith(mockYieldXyzExitRequest);
+            expect(result).toEqual(mockYieldXyzExitResponse);
+        }));
+        it('should propagate errors from mpc.exitYieldXyzYield', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'exitYieldXyzYield').mockRejectedValue(error);
+            yield expect(yieldXyz.exit(mockYieldXyzExitRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('getBalances', () => {
+        it('should call mpc.getYieldXyzBalances with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getYieldXyzBalances')
+                .mockResolvedValue(mockYieldXyzGetBalancesResponse);
+            const result = yield yieldXyz.getBalances(mockYieldXyzGetBalancesRequest);
+            expect(spy).toHaveBeenCalledWith(mockYieldXyzGetBalancesRequest);
+            expect(result).toEqual(mockYieldXyzGetBalancesResponse);
+        }));
+        it('should propagate errors from mpc.getYieldXyzBalances', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'getYieldXyzBalances').mockRejectedValue(error);
+            yield expect(yieldXyz.getBalances(mockYieldXyzGetBalancesRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('getHistoricalActions', () => {
+        it('should call mpc.getYieldXyzHistoricalActions with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getYieldXyzHistoricalActions')
+                .mockResolvedValue(mockYieldXyzGetHistoricalActionsResponse);
+            const result = yield yieldXyz.getHistoricalActions(mockYieldXyzGetHistoricalActionsRequest);
+            expect(spy).toHaveBeenCalledWith(mockYieldXyzGetHistoricalActionsRequest);
+            expect(result).toEqual(mockYieldXyzGetHistoricalActionsResponse);
+        }));
+        it('should propagate errors from mpc.getYieldXyzHistoricalActions', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'getYieldXyzHistoricalActions').mockRejectedValue(error);
+            yield expect(yieldXyz.getHistoricalActions(mockYieldXyzGetHistoricalActionsRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('manage', () => {
+        it('should call mpc.manageYieldXyzYield with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'manageYieldXyzYield')
+                .mockResolvedValue(mockYieldXyzManageYieldResponse);
+            const result = yield yieldXyz.manage(mockYieldXyzManageYieldRequest);
+            expect(spy).toHaveBeenCalledWith(mockYieldXyzManageYieldRequest);
+            expect(result).toEqual(mockYieldXyzManageYieldResponse);
+        }));
+        it('should propagate errors from mpc.manageYieldXyzYield', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'manageYieldXyzYield').mockRejectedValue(error);
+            yield expect(yieldXyz.manage(mockYieldXyzManageYieldRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('track', () => {
+        it('should call mpc.trackYieldXyzTransaction with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'trackYieldXyzTransaction')
+                .mockResolvedValue(mockYieldXyzTrackTransactionResponse);
+            const result = yield yieldXyz.track(mockYieldXyzTrackTransactionRequest);
+            expect(spy).toHaveBeenCalledWith(mockYieldXyzTrackTransactionRequest);
+            expect(result).toEqual(mockYieldXyzTrackTransactionResponse);
+        }));
+        it('should propagate errors from mpc.trackYieldXyzTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'trackYieldXyzTransaction').mockRejectedValue(error);
+            yield expect(yieldXyz.track(mockYieldXyzTrackTransactionRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('getTransaction', () => {
+        it('should call mpc.getYieldXyzTransaction with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const transactionId = 'test-tx-id';
+            const spy = jest
+                .spyOn(mpc, 'getYieldXyzTransaction')
+                .mockResolvedValue(mockYieldXyzGetTransactionResponse);
+            const result = yield yieldXyz.getTransaction(transactionId);
+            expect(spy).toHaveBeenCalledWith(transactionId);
+            expect(result).toEqual(mockYieldXyzGetTransactionResponse);
+        }));
+        it('should propagate errors from mpc.getYieldXyzTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'getYieldXyzTransaction').mockRejectedValue(error);
+            yield expect(yieldXyz.getTransaction('test-tx-id')).rejects.toThrow('Test error');
+        }));
+    });
+});

package/lib/esm/mpc/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { PortalMpcError } from './errors';
 import { BackupMethods, } from '../index';
-const WEB_SDK_VERSION = '3.4.1';
+const WEB_SDK_VERSION = '3.5.0-alpha';
 class Mpc {
     get ready() {
         return this._ready;
@@ -989,9 +989,125 @@ class Mpc {
             });
         });
     }
+    getYieldXyzYields(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:yieldxyz:discover',
+                errorMessage: 'portal:yieldxyz:discoverError',
+                resultMessage: 'portal:yieldxyz:discoverResult',
+                data,
+            });
+        });
+    }
+    enterYieldXyzYield(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:yieldxyz:enter',
+                errorMessage: 'portal:yieldxyz:enterError',
+                resultMessage: 'portal:yieldxyz:enterResult',
+                data,
+            });
+        });
+    }
+    exitYieldXyzYield(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:yieldxyz:exit',
+                errorMessage: 'portal:yieldxyz:exitError',
+                resultMessage: 'portal:yieldxyz:exitResult',
+                data,
+            });
+        });
+    }
+    getYieldXyzBalances(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:yieldxyz:getBalances',
+                errorMessage: 'portal:yieldxyz:getBalancesError',
+                resultMessage: 'portal:yieldxyz:getBalancesResult',
+                data,
+            });
+        });
+    }
+    getYieldXyzHistoricalActions(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:yieldxyz:getHistoricalActions',
+                errorMessage: 'portal:yieldxyz:getHistoricalActionsError',
+                resultMessage: 'portal:yieldxyz:getHistoricalActionsResult',
+                data,
+            });
+        });
+    }
+    manageYieldXyzYield(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:yieldxyz:manage',
+                errorMessage: 'portal:yieldxyz:manageYieldError',
+                resultMessage: 'portal:yieldxyz:manageYieldResult',
+                data,
+            });
+        });
+    }
+    trackYieldXyzTransaction(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:yieldxyz:track',
+                errorMessage: 'portal:yieldxyz:trackError',
+                resultMessage: 'portal:yieldxyz:trackResult',
+                data,
+            });
+        });
+    }
+    getYieldXyzTransaction(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:yieldxyz:getTransaction',
+                errorMessage: 'portal:yieldxyz:getTransactionError',
+                resultMessage: 'portal:yieldxyz:getTransactionResult',
+                data,
+            });
+        });
+    }
     /***************************
      * Private Methods
      ***************************/
+    /**
+     * Util to handle requests to the iframe and post the result to the parent
+     */
+    handleRequestToIframeAndPost({ methodMessage, errorMessage, resultMessage, data, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const handleRequest = (event) => {
+                    const { type, data: result } = event.data;
+                    const { origin } = event;
+                    // ignore any broadcast postMessages
+                    if (origin !== this.getOrigin()) {
+                        return;
+                    }
+                    if (type === errorMessage) {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleRequest);
+                        // Reject the promise with the error
+                        return reject(new PortalMpcError(result));
+                    }
+                    else if (type === resultMessage) {
+                        // Remove the event listener
+                        window.removeEventListener('message', handleRequest);
+                        // Resolve the promise with the result
+                        resolve(result);
+                    }
+                };
+                // Bind the function to the message event
+                window.addEventListener('message', handleRequest);
+                // Send the request to the iframe
+                this.postMessage({
+                    type: methodMessage,
+                    data,
+                });
+            });
+        });
+    }
     /**
      * Appends the iframe to the document body
      */
@@ -1059,6 +1175,11 @@ class Mpc {
         window.addEventListener('message', handleError);
     }
     validateBackupConfig(data) {
+        // Validate that backupMethod is one of the valid BackupMethods
+        const validBackupMethods = Object.values(BackupMethods);
+        if (!validBackupMethods.includes(data.backupMethod)) {
+            throw new Error(`Invalid backup method: ${data.backupMethod}. Valid methods are: ${validBackupMethods.join(', ')}`);
+        }
         if (data.backupMethod === BackupMethods.password) {
             if (!data.backupConfigs.passwordStorage) {
                 throw new Error('Password storage config is required');