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

package/lib/esm/integrations/trading/lifi/lifi.tradeAsset.test.js

@@ -0,0 +1,332 @@
+/**
+ * @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 LiFi, { normalizeChainToNetwork } from './index';
+import Mpc from '../../../mpc';
+import portalMock from '../../../__mocks/portal/portal';
+import { mockEip155Address, mockHost, mockLifiAction, mockLifiGetRouteStepResponse, mockLifiGetRoutesResponse, mockLifiGetStatusResponse, mockLifiRoute, mockLifiStep, } from '../../../__mocks/constants';
+describe('normalizeChainToNetwork', () => {
+    it('maps hex chain ids to eip155', () => {
+        expect(normalizeChainToNetwork('0x1')).toBe('eip155:1');
+        expect(normalizeChainToNetwork('0xa')).toBe('eip155:10');
+        expect(normalizeChainToNetwork('0x89')).toBe('eip155:137');
+    });
+    it('preserves existing eip155 and numeric decimal strings', () => {
+        expect(normalizeChainToNetwork('eip155:42161')).toBe('eip155:42161');
+        expect(normalizeChainToNetwork('42161')).toBe('eip155:42161');
+    });
+});
+describe('LiFi tradeAsset', () => {
+    let mpc;
+    let lifi;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portalMock.host = mockHost;
+        mpc = new Mpc({ portal: portalMock });
+        lifi = new LiFi({
+            mpc,
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return '0xsent'; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return false; }),
+        });
+    });
+    it('throws when waitForConfirmation returns false and does not poll bridge status', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(mpc, 'getLifiRoutes')
+            .mockResolvedValue(mockLifiGetRoutesResponse);
+        jest
+            .spyOn(mpc, 'getLifiRouteStep')
+            .mockResolvedValue(mockLifiGetRouteStepResponse);
+        const pollSpy = jest
+            .spyOn(lifi, 'pollStatus')
+            .mockRejectedValue(new Error('pollStatus should not run'));
+        yield expect(lifi.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+        })).rejects.toThrow(/on-chain confirmation did not complete/);
+        expect(pollSpy).not.toHaveBeenCalled();
+    }));
+    it('strips nonce from EVM transaction request before sign', () => __awaiter(void 0, void 0, void 0, function* () {
+        const swapStep = Object.assign(Object.assign({}, mockLifiStep), { type: 'swap', action: Object.assign(Object.assign({}, mockLifiAction), { fromChainId: 'eip155:1', toChainId: 'eip155:1' }) });
+        const route = Object.assign(Object.assign({}, mockLifiRoute), { fromChainId: 'eip155:1', toChainId: 'eip155:1', steps: [swapStep] });
+        const routesRes = {
+            data: {
+                rawResponse: {
+                    routes: [route],
+                    unavailableRoutes: { filteredOut: [], failed: [] },
+                },
+            },
+        };
+        const stepRes = {
+            data: {
+                rawResponse: Object.assign(Object.assign({}, swapStep), { transactionRequest: Object.assign(Object.assign({}, swapStep.transactionRequest), { nonce: '0xdeadbeef' }) }),
+            },
+        };
+        jest.spyOn(mpc, 'getLifiRoutes').mockResolvedValue(routesRes);
+        jest.spyOn(mpc, 'getLifiRouteStep').mockResolvedValue(stepRes);
+        const signer = jest.fn().mockResolvedValue('0xsigned');
+        const waiter = jest.fn().mockResolvedValue(true);
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: signer,
+            waitForConfirmation: waiter,
+        });
+        yield lifiOk.tradeAsset({
+            fromChain: 'eip155:1',
+            toChain: 'eip155:1',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+        });
+        expect(signer).toHaveBeenCalledTimes(1);
+        const sent = signer.mock.calls[0][0];
+        expect(sent.nonce).toBeUndefined();
+    }));
+    it('emits onProgress failed on unexpected errors (outer catch)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const onProgress = jest.fn();
+        jest.spyOn(mpc, 'getLifiRoutes').mockRejectedValue(new Error('network down'));
+        yield expect(lifi.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+            onProgress,
+        }, {
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return '0x'; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+        })).rejects.toThrow('network down');
+        expect(onProgress).toHaveBeenCalledWith('failed', expect.objectContaining({ errorMessage: 'network down' }));
+    }));
+    it('throws when routeIndex is out of bounds', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(mpc, 'getLifiRoutes')
+            .mockResolvedValue(mockLifiGetRoutesResponse);
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return '0x'; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+        });
+        yield expect(lifiOk.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+            routeIndex: 99,
+        })).rejects.toThrow(/no route available at index 99/);
+    }));
+    it('throws when getRouteStep returns error', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(mpc, 'getLifiRoutes')
+            .mockResolvedValue(mockLifiGetRoutesResponse);
+        jest.spyOn(mpc, 'getLifiRouteStep').mockResolvedValue({
+            error: 'step build failed',
+        });
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return '0x'; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+        });
+        yield expect(lifiOk.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+        })).rejects.toThrow('getRouteStep: step build failed');
+    }));
+    it('cross-chain step calls pollStatus with fast statusPoll options', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(mpc, 'getLifiRoutes')
+            .mockResolvedValue(mockLifiGetRoutesResponse);
+        jest
+            .spyOn(mpc, 'getLifiRouteStep')
+            .mockResolvedValue(mockLifiGetRouteStepResponse);
+        jest
+            .spyOn(mpc, 'getLifiStatus')
+            .mockResolvedValue(mockLifiGetStatusResponse);
+        const pollSpy = jest.spyOn(LiFi.prototype, 'pollStatus');
+        const signer = jest.fn().mockResolvedValue('0xstep1');
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: signer,
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+        });
+        yield lifiOk.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+            statusPoll: {
+                initialDelayMs: 0,
+                everyMs: 5,
+                timeoutMs: 20000,
+            },
+        });
+        expect(signer).toHaveBeenCalled();
+        expect(pollSpy).toHaveBeenCalled();
+        pollSpy.mockRestore();
+    }));
+    it('same-chain swap does not call pollStatus', () => __awaiter(void 0, void 0, void 0, function* () {
+        const swapStep = Object.assign(Object.assign({}, mockLifiStep), { type: 'swap', action: Object.assign(Object.assign({}, mockLifiAction), { fromChainId: 'eip155:1', toChainId: 'eip155:1' }) });
+        const route = Object.assign(Object.assign({}, mockLifiRoute), { fromChainId: 'eip155:1', toChainId: 'eip155:1', steps: [swapStep] });
+        const routesRes = {
+            data: {
+                rawResponse: {
+                    routes: [route],
+                    unavailableRoutes: { filteredOut: [], failed: [] },
+                },
+            },
+        };
+        const stepRes = {
+            data: {
+                rawResponse: Object.assign(Object.assign({}, swapStep), { transactionRequest: Object.assign(Object.assign({}, swapStep.transactionRequest), { chainId: 'eip155:1' }) }),
+            },
+        };
+        jest.spyOn(mpc, 'getLifiRoutes').mockResolvedValue(routesRes);
+        jest.spyOn(mpc, 'getLifiRouteStep').mockResolvedValue(stepRes);
+        const pollSpy = jest.spyOn(LiFi.prototype, 'pollStatus');
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return '0xswap'; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+        });
+        yield lifiOk.tradeAsset({
+            fromChain: 'eip155:1',
+            toChain: 'eip155:1',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+        });
+        expect(pollSpy).not.toHaveBeenCalled();
+        pollSpy.mockRestore();
+    }));
+    it('throws when signer returns empty hash', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(mpc, 'getLifiRoutes')
+            .mockResolvedValue(mockLifiGetRoutesResponse);
+        jest
+            .spyOn(mpc, 'getLifiRouteStep')
+            .mockResolvedValue(mockLifiGetRouteStepResponse);
+        const onProgress = jest.fn();
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return '   '; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+        });
+        yield expect(lifiOk.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+            onProgress,
+        })).rejects.toThrow(/Invalid transaction hash/);
+        expect(onProgress).toHaveBeenCalledWith('failed', expect.objectContaining({ errorMessage: expect.stringContaining('Invalid') }));
+    }));
+    it('emits failed only ONCE when signer returns empty hash (no duplicate)', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(mpc, 'getLifiRoutes')
+            .mockResolvedValue(mockLifiGetRoutesResponse);
+        jest
+            .spyOn(mpc, 'getLifiRouteStep')
+            .mockResolvedValue(mockLifiGetRouteStepResponse);
+        const onProgress = jest.fn();
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return ''; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+        });
+        yield expect(lifiOk.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+            onProgress,
+        })).rejects.toThrow(/Invalid transaction hash/);
+        const failedCalls = onProgress.mock.calls.filter((call) => call[0] === 'failed');
+        expect(failedCalls).toHaveLength(1);
+        expect(failedCalls[0][1]).toMatchObject({
+            errorMessage: expect.stringContaining('Invalid transaction hash'),
+            stepIndex: 0,
+            totalSteps: 1,
+        });
+    }));
+    it('emits failed only ONCE when waitForConfirmation returns false (no duplicate)', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(mpc, 'getLifiRoutes')
+            .mockResolvedValue(mockLifiGetRoutesResponse);
+        jest
+            .spyOn(mpc, 'getLifiRouteStep')
+            .mockResolvedValue(mockLifiGetRouteStepResponse);
+        const onProgress = jest.fn();
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return '0xhash'; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () { return false; }),
+        });
+        yield expect(lifiOk.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+            onProgress,
+        })).rejects.toThrow(/on-chain confirmation did not complete/);
+        const failedCalls = onProgress.mock.calls.filter((call) => call[0] === 'failed');
+        expect(failedCalls).toHaveLength(1);
+        expect(failedCalls[0][1]).toMatchObject({
+            errorMessage: expect.stringContaining('on-chain confirmation'),
+            txHash: '0xhash',
+            stepIndex: 0,
+            totalSteps: 1,
+        });
+    }));
+    it('throws when waitForConfirmation throws', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(mpc, 'getLifiRoutes')
+            .mockResolvedValue(mockLifiGetRoutesResponse);
+        jest
+            .spyOn(mpc, 'getLifiRouteStep')
+            .mockResolvedValue(mockLifiGetRouteStepResponse);
+        const lifiOk = new LiFi({
+            mpc,
+            signAndSendTransaction: () => __awaiter(void 0, void 0, void 0, function* () { return '0xabc'; }),
+            waitForConfirmation: () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error('waiter boom');
+            }),
+        });
+        yield expect(lifiOk.tradeAsset({
+            fromChain: 'eip155:8453',
+            toChain: 'eip155:42161',
+            fromToken: 'ETH',
+            toToken: 'USDC',
+            amount: '1000000000000000',
+            fromAddress: mockEip155Address,
+        })).rejects.toThrow('waiter boom');
+    }));
+});

package/lib/esm/integrations/trading/lifi/lifiStatusPoll.js

@@ -0,0 +1,113 @@
+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());
+    });
+};
+/**
+ * LiFi status polling: domain tick (DONE / FAILED / indexer lag) over shared {@link pollLoop}.
+ */
+import { sdkLogger } from '../../../logger';
+import { pollLoop, PollLoopTimeoutError, } from '../../../internal/pollLoop';
+const LOG_PREFIX = '[LiFi.pollStatus]';
+const INDEXER_LAG_MESSAGE_SNIPPETS = [
+    'not an evm transaction',
+    'no transfer information found',
+    'transfer not found',
+];
+export function isLikelyLifiIndexerNotReadyMessage(message) {
+    const m = message.toLowerCase();
+    return INDEXER_LAG_MESSAGE_SNIPPETS.some((s) => m.includes(s));
+}
+export function pollLifiStatusUntilTerminal(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let consecutiveHardErrors = 0;
+        try {
+            return yield pollLoop({
+                tick: () => __awaiter(this, void 0, void 0, function* () {
+                    return lifiStatusPollTick(params, {
+                        get: () => consecutiveHardErrors,
+                        set: (n) => {
+                            consecutiveHardErrors = n;
+                        },
+                    });
+                }),
+                intervalMs: params.everyMs,
+                initialDelayMs: params.initialDelayMs,
+                backoff: params.backoff,
+                timeoutMs: params.timeoutMs,
+            });
+        }
+        catch (error) {
+            if (error instanceof PollLoopTimeoutError) {
+                throw new Error(`${LOG_PREFIX} timed out after ${params.timeoutMs}ms waiting for LiFi terminal status`);
+            }
+            throw error;
+        }
+    });
+}
+function lifiStatusPollTick(params, counter) {
+    var _a, _b, _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const res = yield params.getStatus(params.request);
+            if (res.error) {
+                sdkLogger.warn(`${LOG_PREFIX} response error field`, res.error);
+                return bumpHardError(counter, params.maxConsecutiveErrors);
+            }
+            counter.set(0);
+            const raw = (_a = res.data) === null || _a === void 0 ? void 0 : _a.rawResponse;
+            if (!raw) {
+                return { kind: 'continue' };
+            }
+            const { status } = raw;
+            if (status === 'INVALID') {
+                return {
+                    kind: 'throw',
+                    error: new Error(`${LOG_PREFIX} LiFi status INVALID for ${params.request.txHash}`),
+                };
+            }
+            if (status === 'DONE') {
+                return { kind: 'stop', value: raw };
+            }
+            if (status === 'FAILED') {
+                const detail = (_c = (_b = raw.substatusMessage) !== null && _b !== void 0 ? _b : raw.substatus) !== null && _c !== void 0 ? _c : 'LiFi transfer FAILED';
+                return {
+                    kind: 'throw',
+                    error: new Error(`${LOG_PREFIX} ${detail}`),
+                };
+            }
+            if (params.onUpdate) {
+                const carryOn = params.onUpdate(raw);
+                if (carryOn === false) {
+                    return { kind: 'stop', value: raw };
+                }
+            }
+            return { kind: 'continue' };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (isLikelyLifiIndexerNotReadyMessage(message)) {
+                sdkLogger.debug(`${LOG_PREFIX} indexer not ready, will retry`, message);
+                counter.set(0);
+                return { kind: 'continue' };
+            }
+            sdkLogger.warn(`${LOG_PREFIX} getStatus error`, error);
+            return bumpHardError(counter, params.maxConsecutiveErrors);
+        }
+    });
+}
+function bumpHardError(counter, max) {
+    const next = counter.get() + 1;
+    counter.set(next);
+    if (next >= max) {
+        return {
+            kind: 'throw',
+            error: new Error(`${LOG_PREFIX} too many consecutive getStatus failures (${max})`),
+        };
+    }
+    return { kind: 'continue' };
+}

package/lib/esm/integrations/trading/lifi/lifiStatusPoll.test.js

@@ -0,0 +1,64 @@
+/**
+ * @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 { pollLifiStatusUntilTerminal, isLikelyLifiIndexerNotReadyMessage, } from './lifiStatusPoll';
+describe('lifiStatusPoll', () => {
+    describe('isLikelyLifiIndexerNotReadyMessage', () => {
+        it('returns true for known indexer lag phrases', () => {
+            expect(isLikelyLifiIndexerNotReadyMessage('No transfer information found')).toBe(true);
+            expect(isLikelyLifiIndexerNotReadyMessage('transfer not found')).toBe(true);
+        });
+        it('returns false for unrelated errors', () => {
+            expect(isLikelyLifiIndexerNotReadyMessage('Network error 400')).toBe(false);
+        });
+    });
+    describe('pollLifiStatusUntilTerminal', () => {
+        it('treats response error field as hard error without resetting counter incorrectly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getStatus = jest
+                .fn()
+                .mockResolvedValueOnce({
+                error: 'temporary',
+                data: undefined,
+            })
+                .mockResolvedValueOnce({
+                data: { rawResponse: { status: 'DONE' } },
+            });
+            const result = yield pollLifiStatusUntilTerminal({
+                getStatus,
+                request: { txHash: '0x1' },
+                everyMs: 5,
+                initialDelayMs: 0,
+                timeoutMs: 5000,
+                maxConsecutiveErrors: 10,
+            });
+            expect(result.status).toBe('DONE');
+            expect(getStatus).toHaveBeenCalledTimes(2);
+        }));
+        it('retries on indexer lag message without counting as hard error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const getStatus = jest
+                .fn()
+                .mockRejectedValueOnce(new Error('transfer not found'))
+                .mockResolvedValue({
+                data: { rawResponse: { status: 'DONE' } },
+            });
+            const result = yield pollLifiStatusUntilTerminal({
+                getStatus,
+                request: { txHash: '0x1' },
+                everyMs: 5,
+                initialDelayMs: 0,
+                timeoutMs: 5000,
+                maxConsecutiveErrors: 2,
+            });
+            expect(result.status).toBe('DONE');
+        }));
+    });
+});