@portal-hq/web 3.4.1 → 3.5.0-alpha

package/lib/commonjs/mpc/index.test.js

@@ -197,6 +197,25 @@ describe('Mpc', () => {
                 done();
             });
         });
+        it('should error out if backupMethod is invalid', (done) => {
+            mpc
+                .backup({
+                backupMethod: 'INVALID_METHOD',
+                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', () => {
         it('should clear local wallet', (done) => {
@@ -1699,4 +1718,524 @@ describe('Mpc', () => {
             });
         });
     });
+    describe('getYieldXyzYields', () => {
+        const args = constants_1.mockYieldXyzGetYieldsRequest;
+        const res = constants_1.mockYieldXyzGetYieldsResponse;
+        it('should successfully return the yields', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, 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) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, 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(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('enterYieldXyzYield', () => {
+        const args = constants_1.mockYieldXyzEnterRequest;
+        const res = constants_1.mockYieldXyzEnterResponse;
+        it('should successfully enter the yield', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, 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) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, 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(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('exitYieldXyzYield', () => {
+        const args = constants_1.mockYieldXyzExitRequest;
+        const res = constants_1.mockYieldXyzExitResponse;
+        it('should successfully exit the yield', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, 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) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, 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(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('getYieldXyzBalances', () => {
+        const args = constants_1.mockYieldXyzGetBalancesRequest;
+        const res = constants_1.mockYieldXyzGetBalancesResponse;
+        it('should successfully return the balances', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, 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) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, 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(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('getYieldXyzHistoricalActions', () => {
+        const args = constants_1.mockYieldXyzGetHistoricalActionsRequest;
+        const res = constants_1.mockYieldXyzGetHistoricalActionsResponse;
+        it('should successfully return the historical actions', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, 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) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, 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(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('manageYieldXyzYield', () => {
+        const args = constants_1.mockYieldXyzManageYieldRequest;
+        const res = constants_1.mockYieldXyzManageYieldResponse;
+        it('should successfully manage the yield', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, 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) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, 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(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('trackYieldXyzTransaction', () => {
+        const args = constants_1.mockYieldXyzTrackTransactionRequest;
+        const res = constants_1.mockYieldXyzTrackTransactionResponse;
+        it('should successfully track the transaction', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, 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) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, 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(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
+    describe('getYieldXyzTransaction', () => {
+        const args = 'test-tx-id';
+        const res = constants_1.mockYieldXyzGetTransactionResponse;
+        it('should successfully return the transaction', (done) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementation((message, 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) => {
+            var _a;
+            jest
+                .spyOn((_a = mpc.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow, 'postMessage')
+                .mockImplementationOnce((message, 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(errors_1.PortalMpcError);
+                expect(e.message).toEqual('test');
+                expect(e.code).toEqual(1);
+                done();
+            });
+        });
+    });
 });

package/lib/esm/index.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Connection, PublicKey, Transaction as SolanaTransaction, SystemProgram, } from '@solana/web3.js';
 import Mpc from './mpc';
 import Provider, { RequestMethod } from './provider';
+import Yield from './integrations/yield';
 class Portal {
     get ready() {
         return this.mpc.ready;
@@ -52,6 +53,7 @@ class Portal {
         this.mpc = new Mpc({
             portal: this,
         });
+        this.yield = new Yield({ mpc: this.mpc });
         this.provider = new Provider({
             portal: this,
             chainId: chainId ? Number(chainId) : undefined,

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

@@ -0,0 +1,10 @@
+import YieldXyz from './yieldxyz';
+/**
+ * This class is a container for the YieldXyz class.
+ * In the future, Yield domain logic should be here.
+ */
+export default class Yield {
+    constructor({ mpc }) {
+        this.yieldXyz = new YieldXyz({ mpc });
+    }
+}

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

@@ -0,0 +1,112 @@
+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());
+    });
+};
+export default 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);
+        });
+    }
+}