@portal-hq/web 3.13.2 → 3.14.0-alpha.0

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

@@ -0,0 +1,325 @@
+/**
+ * @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 { mockAddress, mockHost } from '../../__mocks/constants';
+describe('YieldXyz high-level (deposit, withdraw, defaults)', () => {
+    let mpc;
+    let yieldXyz;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portalMock.host = mockHost;
+        mpc = new Mpc({ portal: portalMock });
+        yieldXyz = new YieldXyz({ mpc });
+        yieldXyz.setSignAndSendTransaction(jest.fn().mockResolvedValue('0xabc'));
+    });
+    function enterResponseWithTxs(txs) {
+        return {
+            data: {
+                rawResponse: {
+                    id: 'action-1',
+                    intent: 'enter',
+                    type: 'STAKE',
+                    yieldId: 'resolved-yield',
+                    address: mockAddress,
+                    createdAt: '2024-01-01T00:00:00Z',
+                    status: 'CREATED',
+                    executionPattern: 'synchronous',
+                    transactions: txs,
+                },
+            },
+        };
+    }
+    function exitResponseWithTxs(txs) {
+        return {
+            data: {
+                rawResponse: {
+                    id: 'action-1',
+                    intent: 'exit',
+                    type: 'UNSTAKE',
+                    yieldId: 'resolved-yield',
+                    address: mockAddress,
+                    createdAt: '2024-01-01T00:00:00Z',
+                    status: 'CREATED',
+                    executionPattern: 'synchronous',
+                    transactions: txs,
+                },
+            },
+        };
+    }
+    it('deposit throws when no signer is configured', () => __awaiter(void 0, void 0, void 0, function* () {
+        const y = new YieldXyz({ mpc });
+        yield expect(y.deposit({ yieldId: 'y1', amount: '1', address: mockAddress })).rejects.toThrow('[YieldXyz] No signer configured. Call setSignAndSendTransaction()');
+    }));
+    it('deposit throws when chain is not full CAIP-2', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect(yieldXyz.deposit({
+            chain: '1',
+            token: 'ETH',
+            amount: '1',
+            address: mockAddress,
+        })).rejects.toThrow('full CAIP-2');
+    }));
+    it('deposit throws when neither yieldId nor chain+token', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect(yieldXyz.deposit({ amount: '1', address: mockAddress })).rejects.toThrow('Provide either yieldId');
+    }));
+    it('resolveYieldIdFromPortalDefaults: throws when defaults endpoint returns error', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(mpc, 'getYieldXyzDefaults').mockResolvedValue({
+            error: 'boom',
+        });
+        yield expect(yieldXyz.deposit({
+            chain: 'eip155:1',
+            token: 'ETH',
+            amount: '1',
+            address: mockAddress,
+        })).rejects.toThrow('Failed to get yield defaults');
+    }));
+    it('resolveYieldIdFromPortalDefaults: throws when no data', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(mpc, 'getYieldXyzDefaults').mockResolvedValue({});
+        yield expect(yieldXyz.deposit({
+            chain: 'eip155:1',
+            token: 'ETH',
+            amount: '1',
+            address: mockAddress,
+        })).rejects.toThrow('No data returned from yield defaults endpoint');
+    }));
+    it('resolveYieldIdFromPortalDefaults: throws when key missing', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(mpc, 'getYieldXyzDefaults').mockResolvedValue({
+            data: { 'eip155:1:WETH': { yieldId: 'y', opportunity: null } },
+        });
+        yield expect(yieldXyz.deposit({
+            chain: 'eip155:1',
+            token: 'ETH',
+            amount: '1',
+            address: mockAddress,
+        })).rejects.toThrow('No default yield for key "eip155:1:ETH"');
+    }));
+    it('resolveYieldIdFromPortalDefaults: trims token for map key', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(mpc, 'getYieldXyzDefaults').mockResolvedValue({
+            data: {
+                'eip155:1:ETH': { yieldId: 'yield-from-defaults', opportunity: null },
+            },
+        });
+        const enterSpy = jest
+            .spyOn(mpc, 'enterYieldXyzYield')
+            .mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'ethereum',
+                unsignedTransaction: { to: '0x1', data: '0x' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({
+            data: { rawResponse: { status: 'BROADCASTED' } },
+        });
+        yield yieldXyz.deposit({
+            chain: 'eip155:1',
+            token: '  ETH  ',
+            amount: '1',
+            address: mockAddress,
+        });
+        expect(mpc.getYieldXyzDefaults).toHaveBeenCalledWith({
+            includeOpportunities: false,
+        });
+        expect(enterSpy).toHaveBeenCalledWith(expect.objectContaining({ yieldId: 'yield-from-defaults' }));
+    }));
+    it('deposit merges arguments so top-level amount wins', () => __awaiter(void 0, void 0, void 0, function* () {
+        const enterSpy = jest
+            .spyOn(mpc, 'enterYieldXyzYield')
+            .mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x2', data: '0x' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        yield yieldXyz.deposit({
+            yieldId: 'y1',
+            amount: '10',
+            address: mockAddress,
+            arguments: { amount: '99', validatorAddress: '0xv' },
+        });
+        expect(enterSpy).toHaveBeenCalledWith({
+            yieldId: 'y1',
+            address: mockAddress,
+            arguments: {
+                amount: '10',
+                validatorAddress: '0xv',
+            },
+        });
+    }));
+    it('withdraw merges arguments so top-level amount wins (consistent with deposit)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const exitSpy = jest.spyOn(mpc, 'exitYieldXyzYield').mockResolvedValue(exitResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x2', data: '0x' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        yield yieldXyz.withdraw({
+            yieldId: 'y1',
+            amount: '10',
+            address: mockAddress,
+            arguments: { amount: '77' },
+        });
+        expect(exitSpy).toHaveBeenCalledWith({
+            yieldId: 'y1',
+            address: mockAddress,
+            arguments: { amount: '10' },
+        });
+    }));
+    it('executeAndTrack: throws when no transactions', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue({
+            data: {
+                rawResponse: {
+                    id: 'a',
+                    intent: 'enter',
+                    type: 'STAKE',
+                    yieldId: 'y',
+                    address: mockAddress,
+                    createdAt: '2024-01-01T00:00:00Z',
+                    status: 'CREATED',
+                    executionPattern: 'synchronous',
+                    transactions: [],
+                },
+            },
+        });
+        yield expect(yieldXyz.deposit({ yieldId: 'y', amount: '1', address: mockAddress })).rejects.toThrow('No transactions in yield action response.');
+    }));
+    it('executeAndTrack: single tx signs, tracks, returns hashes', () => __awaiter(void 0, void 0, void 0, function* () {
+        const sign = jest.fn().mockResolvedValue('0xsig');
+        yieldXyz.setSignAndSendTransaction(sign);
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'ethereum',
+                unsignedTransaction: JSON.stringify({
+                    to: '0xabc',
+                    nonce: '0x1',
+                    data: '0x',
+                }),
+            },
+        ]));
+        const trackSpy = jest
+            .spyOn(mpc, 'trackYieldXyzTransaction')
+            .mockResolvedValue({});
+        const result = yield yieldXyz.deposit({ yieldId: 'rid', amount: '1', address: mockAddress });
+        expect(sign).toHaveBeenCalledTimes(1);
+        expect(trackSpy).toHaveBeenCalledWith({
+            transactionId: 'tx1',
+            hash: '0xsig',
+        });
+        expect(result.hashes).toEqual(['0xsig']);
+        expect(result.yieldId).toBe('resolved-yield');
+    }));
+    it('executeAndTrack: multi-tx sequential', () => __awaiter(void 0, void 0, void 0, function* () {
+        const sign = jest
+            .fn()
+            .mockResolvedValueOnce('0x1')
+            .mockResolvedValueOnce('0x2');
+        yieldXyz.setSignAndSendTransaction(sign);
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'a',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+            {
+                id: 'b',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x2' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const result = yield yieldXyz.deposit({ yieldId: 'r', amount: '1', address: mockAddress });
+        expect(sign).toHaveBeenCalledTimes(2);
+        expect(result.hashes).toEqual(['0x1', '0x2']);
+    }));
+    it('waitForConfirmation false: still tracks but no confirmed progress', () => __awaiter(void 0, void 0, void 0, function* () {
+        const progress = [];
+        const waiter = jest.fn().mockResolvedValue(false);
+        const y = new YieldXyz({
+            mpc,
+            waitForConfirmation: waiter,
+        });
+        y.setSignAndSendTransaction(jest.fn().mockResolvedValue('0xh'));
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+        ]));
+        const trackSpy = jest
+            .spyOn(mpc, 'trackYieldXyzTransaction')
+            .mockResolvedValue({});
+        yield y.deposit({ yieldId: 'y', amount: '1', address: mockAddress }, {
+            onProgress: (e) => progress.push(e.step),
+        });
+        expect(progress).toEqual([
+            'signing',
+            'submitted',
+            'confirming',
+        ]);
+        expect(progress.includes('confirmed')).toBe(false);
+        expect(trackSpy).toHaveBeenCalledWith({
+            transactionId: 'tx1',
+            hash: '0xh',
+        });
+    }));
+    it('waitForConfirmation true: emits confirmed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const progress = [];
+        const y = new YieldXyz({
+            mpc,
+            waitForConfirmation: jest.fn().mockResolvedValue(true),
+        });
+        y.setSignAndSendTransaction(jest.fn().mockResolvedValue('0xh'));
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        yield y.deposit({ yieldId: 'y', amount: '1', address: mockAddress }, {
+            onProgress: (e) => progress.push(e.step),
+        });
+        expect(progress).toContain('confirmed');
+    }));
+    it('echoes chain and token on result when resolved from defaults', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(mpc, 'getYieldXyzDefaults').mockResolvedValue({
+            data: {
+                'eip155:1:ETH': { yieldId: 'ydef', opportunity: null },
+            },
+        });
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield yieldXyz.deposit({
+            chain: 'eip155:1',
+            token: 'ETH',
+            amount: '1',
+            address: mockAddress,
+        });
+        expect(r.chain).toBe('eip155:1');
+        expect(r.token).toBe('ETH');
+    }));
+});