@portal-hq/web 3.4.1 → 3.4.2

package/lib/commonjs/index.js

@@ -39,6 +39,7 @@ exports.ChainNamespace = exports.PortalCurve = exports.GetTransactionsOrder = ex
 const web3_js_1 = require("@solana/web3.js");
 const mpc_1 = __importDefault(require("./mpc"));
 const provider_1 = __importStar(require("./provider"));
+const yield_1 = __importDefault(require("./integrations/yield"));
 class Portal {
     get ready() {
         return this.mpc.ready;
@@ -81,6 +82,7 @@ class Portal {
         this.mpc = new mpc_1.default({
             portal: this,
         });
+        this.yield = new yield_1.default({ mpc: this.mpc });
         this.provider = new provider_1.default({
             portal: this,
             chainId: chainId ? Number(chainId) : undefined,

package/lib/commonjs/integrations/yield/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yieldxyz_1 = __importDefault(require("./yieldxyz"));
+/**
+ * This class is a container for the YieldXyz class.
+ * In the future, Yield domain logic should be here.
+ */
+class Yield {
+    constructor({ mpc }) {
+        this.yieldXyz = new yieldxyz_1.default({ mpc });
+    }
+}
+exports.default = Yield;

package/lib/commonjs/integrations/yield/yieldxyz.js

@@ -0,0 +1,115 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class YieldXyz {
+    constructor({ mpc }) {
+        this.mpc = mpc;
+    }
+    /**
+     * Retrieves yield balances for specified addresses and networks.
+     * @param data - The parameters for the yield balances request.
+     * @returns A `YieldXyzGetBalancesResponse` promise, resolving to balance information.
+     * @throws An error if the operation fails.
+     */
+    getBalances(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getYieldXyzBalances(data);
+        });
+    }
+    /**
+     * Retrieves historical yield actions with optional filtering.
+     * @param data - The parameters for the historical yield actions request.
+     * @returns A `YieldXyzGetHistoricalActionsResponse` promise, resolving to historical actions.
+     * @throws An error if the operation fails.
+     */
+    getHistoricalActions(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getYieldXyzHistoricalActions(data);
+        });
+    }
+    /**
+     * Manages a yield opportunity with the specified parameters.
+     * @param data - The parameters for managing a yield opportunity.
+     * @returns A `YieldXyzManageYieldResponse` promise, resolving to the action details.
+     * @throws An error if the operation fails.
+     */
+    manage(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.manageYieldXyzYield(data);
+        });
+    }
+    /**
+     * Enters a yield opportunity with the specified parameters.
+     * @param data - The parameters for entering a yield opportunity.
+     * @returns A `YieldXyzEnterYieldResponse` promise, resolving to the action details.
+     * @throws An error if the operation fails.
+     */
+    enter(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.enterYieldXyzYield(data);
+        });
+    }
+    /**
+     * Exits a yield opportunity with the specified parameters.
+     * @param data - The parameters for exiting a yield opportunity.
+     * @returns A `YieldXyzExitResponse` promise, resolving to the action details.
+     * @throws An error if the operation fails.
+     */
+    exit(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.exitYieldXyzYield(data);
+        });
+    }
+    /**
+     * Discovers yield opportunities based on the provided parameters.
+     * @param data - Optional parameters for yield discovery. If undefined, uses default parameters.
+     * @returns A `YieldXyzGetYieldsResponse` promise, resolving to available yield opportunities.
+     * @throws An error if the operation fails.
+     */
+    discover(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getYieldXyzYields(data);
+        });
+    }
+    /**
+     * Tracks a transaction by submitting its hash to the Yield.xyz integration.
+     * @param data - The parameters for tracking a transaction:
+     *   - transactionId: The ID of the transaction to track.
+     *   - txHash: The hash of the transaction to submit.
+     * @returns A `YieldXyzTrackTransactionResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    track(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.trackYieldXyzTransaction(data);
+        });
+    }
+    /**
+     * Retrieves a single yield action transaction by its ID.
+     * @param transactionId - The ID of the transaction to retrieve.
+     * @returns A `YieldXyzGetTransactionResponse` promise, resolving to transaction details.
+     * @throws An error if the operation fails.
+     */
+    getTransaction(transactionId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getYieldXyzTransaction(transactionId);
+        });
+    }
+}
+exports.default = YieldXyz;

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

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * @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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yieldxyz_1 = __importDefault(require("./yieldxyz"));
+const mpc_1 = __importDefault(require("../../mpc"));
+const portal_1 = __importDefault(require("../../__mocks/portal/portal"));
+const constants_1 = require("../../__mocks/constants");
+describe('YieldXyz', () => {
+    let yieldXyz;
+    let mpc;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portal_1.default.host = constants_1.mockHost;
+        mpc = new mpc_1.default({
+            portal: portal_1.default,
+        });
+        yieldXyz = new yieldxyz_1.default({ 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(constants_1.mockYieldXyzGetYieldsResponse);
+            const result = yield yieldXyz.discover(constants_1.mockYieldXyzGetYieldsRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockYieldXyzGetYieldsRequest);
+            expect(result).toEqual(constants_1.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(constants_1.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(constants_1.mockYieldXyzEnterResponse);
+            const result = yield yieldXyz.enter(constants_1.mockYieldXyzEnterRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockYieldXyzEnterRequest);
+            expect(result).toEqual(constants_1.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(constants_1.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(constants_1.mockYieldXyzExitResponse);
+            const result = yield yieldXyz.exit(constants_1.mockYieldXyzExitRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockYieldXyzExitRequest);
+            expect(result).toEqual(constants_1.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(constants_1.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(constants_1.mockYieldXyzGetBalancesResponse);
+            const result = yield yieldXyz.getBalances(constants_1.mockYieldXyzGetBalancesRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockYieldXyzGetBalancesRequest);
+            expect(result).toEqual(constants_1.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(constants_1.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(constants_1.mockYieldXyzGetHistoricalActionsResponse);
+            const result = yield yieldXyz.getHistoricalActions(constants_1.mockYieldXyzGetHistoricalActionsRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockYieldXyzGetHistoricalActionsRequest);
+            expect(result).toEqual(constants_1.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(constants_1.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(constants_1.mockYieldXyzManageYieldResponse);
+            const result = yield yieldXyz.manage(constants_1.mockYieldXyzManageYieldRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockYieldXyzManageYieldRequest);
+            expect(result).toEqual(constants_1.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(constants_1.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(constants_1.mockYieldXyzTrackTransactionResponse);
+            const result = yield yieldXyz.track(constants_1.mockYieldXyzTrackTransactionRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockYieldXyzTrackTransactionRequest);
+            expect(result).toEqual(constants_1.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(constants_1.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(constants_1.mockYieldXyzGetTransactionResponse);
+            const result = yield yieldXyz.getTransaction(transactionId);
+            expect(spy).toHaveBeenCalledWith(transactionId);
+            expect(result).toEqual(constants_1.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/commonjs/mpc/index.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MpcErrorCodes = exports.MpcError = void 0;
 const errors_1 = require("./errors");
 const index_1 = require("../index");
-const WEB_SDK_VERSION = '3.4.1';
+const WEB_SDK_VERSION = '3.4.2';
 class Mpc {
     get ready() {
         return this._ready;
@@ -992,9 +992,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 errors_1.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
      */
@@ -1062,6 +1178,11 @@ class Mpc {
         window.addEventListener('message', handleError);
     }
     validateBackupConfig(data) {
+        // Validate that backupMethod is one of the valid BackupMethods
+        const validBackupMethods = Object.values(index_1.BackupMethods);
+        if (!validBackupMethods.includes(data.backupMethod)) {
+            throw new Error(`Invalid backup method: ${data.backupMethod}. Valid methods are: ${validBackupMethods.join(', ')}`);
+        }
         if (data.backupMethod === index_1.BackupMethods.password) {
             if (!data.backupConfigs.passwordStorage) {
                 throw new Error('Password storage config is required');