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

package/lib/commonjs/integrations/trading/lifi/index.js

@@ -8,58 +8,330 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusBridgeFromStepTool = exports.parseLifiTransactionRequestFromStep = exports.resolveLifiStepNetworkCaip2 = exports.normalizeChainToNetwork = void 0;
+const logger_1 = require("../../../logger");
+const waitForEvmTxConfirmation_1 = require("../../../internal/waitForEvmTxConfirmation");
+const stripStalePlanningNonce_1 = require("../../../internal/stripStalePlanningNonce");
+const lifiStatusPoll_1 = require("./lifiStatusPoll");
+const LOG_PREFIX = '[LiFi]';
+/**
+ * Internal sentinel error used to avoid emitting duplicate `failed` progress events.
+ */
+class LifiReportedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LifiReportedError';
+    }
+}
+/** Normalize LiFi chain key / id to CAIP-2 `eip155:*` for the Portal provider. */
+function normalizeChainToNetwork(chain) {
+    const c = chain.trim();
+    if (c.startsWith('eip155:')) {
+        return c;
+    }
+    if (/^0x[0-9a-fA-F]+$/.test(c)) {
+        return `eip155:${parseInt(c, 16)}`;
+    }
+    if (/^\d+$/.test(c)) {
+        return `eip155:${c}`;
+    }
+    return c;
+}
+exports.normalizeChainToNetwork = normalizeChainToNetwork;
+function resolveLifiStepNetworkCaip2(step) {
+    var _a;
+    const fromTx = (_a = step.transactionRequest) === null || _a === void 0 ? void 0 : _a.chainId;
+    if (fromTx) {
+        return normalizeChainToNetwork(fromTx);
+    }
+    return normalizeChainToNetwork(step.action.fromChainId);
+}
+exports.resolveLifiStepNetworkCaip2 = resolveLifiStepNetworkCaip2;
+function parseLifiTransactionRequestFromStep(step) {
+    var _a;
+    const tr = step.transactionRequest;
+    if (!tr) {
+        throw new Error(`${LOG_PREFIX} Step has no transactionRequest; call getRouteStep first.`);
+    }
+    const base = {
+        data: tr.data,
+        to: tr.to,
+        from: tr.from,
+        value: (_a = tr.value) !== null && _a !== void 0 ? _a : '0x0',
+        gas: tr.gasLimit,
+        gasPrice: tr.gasPrice,
+    };
+    if (tr.maxFeePerGas != null) {
+        base.maxFeePerGas = tr.maxFeePerGas;
+    }
+    if (tr.maxPriorityFeePerGas != null) {
+        base.maxPriorityFeePerGas = tr.maxPriorityFeePerGas;
+    }
+    return base;
+}
+exports.parseLifiTransactionRequestFromStep = parseLifiTransactionRequestFromStep;
+function statusBridgeFromStepTool(tool) {
+    if (!tool) {
+        return undefined;
+    }
+    return tool.toLowerCase();
+}
+exports.statusBridgeFromStepTool = statusBridgeFromStepTool;
+function mergeLifiOptions(instance, perCall) {
+    return Object.assign(Object.assign({}, instance), perCall);
+}
 class LiFi {
-    constructor({ mpc }) {
+    constructor(_a) {
+        var { mpc } = _a, tradeDefaults = __rest(_a, ["mpc"]);
         this.mpc = mpc;
+        this.defaultTradeOptions = tradeDefaults;
     }
-    /**
-     * Retrieves routes from the Li.Fi integration.
-     * @param data - The parameters for the routes request.
-     * @returns A `LifiRoutesResponse` promise.
-     * @throws An error if the operation fails.
-     */
     getRoutes(data) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getLifiRoutes(data);
         });
     }
-    /**
-     * Retrieves a quote from the Li.Fi integration.
-     * @param data - The parameters for the quote request.
-     * @returns A `LifiQuoteResponse` promise.
-     * @throws An error if the operation fails.
-     */
     getQuote(data) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getLifiQuote(data);
         });
     }
-    /**
-     * Retrieves the status of a transaction from the Li.Fi integration.
-     * @param data - The parameters for the status request.
-     * @returns A `LifiStatusResponse` promise.
-     * @throws An error if the operation fails.
-     */
     getStatus(data) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getLifiStatus(data);
         });
     }
-    /**
-     * Retrieves an unsigned transaction from the Li.Fi integration that has yet to be signed/submitted.
-     * @param data - The step transaction request containing the step details.
-     * @returns A `LifiStepTransactionResponse` promise.
-     * @throws An error if the operation fails.
-     */
     getRouteStep(data) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getLifiRouteStep(data);
         });
     }
+    pollStatus(request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { everyMs = 10000, initialDelayMs = 10000, timeoutMs = 600000, maxConsecutiveErrors = 10, backoff = { factor: 1.5, maxIntervalMs: 15000 }, onUpdate, } = options !== null && options !== void 0 ? options : {};
+            return (0, lifiStatusPoll_1.pollLifiStatusUntilTerminal)({
+                getStatus: (r) => this.mpc.getLifiStatus(r),
+                request,
+                onUpdate,
+                everyMs,
+                initialDelayMs,
+                timeoutMs,
+                maxConsecutiveErrors,
+                backoff,
+            });
+        });
+    }
+    tradeAsset(params, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const o = mergeLifiOptions(this.defaultTradeOptions, options);
+                const signAndSend = o.signAndSendTransaction;
+                if (!signAndSend) {
+                    throw new Error(`${LOG_PREFIX} tradeAsset requires signAndSendTransaction`);
+                }
+                const effectiveWait = (txHash, network) => __awaiter(this, void 0, void 0, function* () {
+                    var _u, _v;
+                    if (o.waitForConfirmation) {
+                        return o.waitForConfirmation(txHash, network);
+                    }
+                    if (o.evmRequestFn) {
+                        if (!network.startsWith('eip155:')) {
+                            logger_1.sdkLogger.warn(`${LOG_PREFIX} Cannot verify confirmation for non-EVM network ${network}. ` +
+                                'Provide waitForConfirmation or use Portal.waitForConfirmation.');
+                            return Promise.resolve(false);
+                        }
+                        return (0, waitForEvmTxConfirmation_1.waitForEvmTxConfirmation)(txHash, network, o.evmRequestFn, {
+                            pollIntervalMs: (_u = o.evmPollerOptions) === null || _u === void 0 ? void 0 : _u.pollIntervalMs,
+                            timeoutMs: (_v = o.evmPollerOptions) === null || _v === void 0 ? void 0 : _v.timeoutMs,
+                            // Intentionally differs from Yield's optimistic `resolve_false` timeout
+                            // handling: LiFi must abort here so we do not continue into bridge-status
+                            // polling after source-chain confirmation has already timed out.
+                            onTimeout: 'throw',
+                        });
+                    }
+                    throw new Error(`${LOG_PREFIX} tradeAsset requires waitForConfirmation or evmRequestFn fallback.`);
+                });
+                (_a = params.onProgress) === null || _a === void 0 ? void 0 : _a.call(params, 'fetching_routes');
+                const routesRes = yield this.getRoutes({
+                    fromChainId: normalizeChainToNetwork(params.fromChain),
+                    toChainId: normalizeChainToNetwork(params.toChain),
+                    fromTokenAddress: params.fromToken,
+                    toTokenAddress: params.toToken,
+                    fromAmount: params.amount,
+                    fromAddress: params.fromAddress,
+                    toAddress: params.toAddress,
+                    options: params.routeOptions,
+                });
+                if (routesRes.error) {
+                    throw new Error(`${LOG_PREFIX} getRoutes: ${routesRes.error}`);
+                }
+                const routes = (_c = (_b = routesRes.data) === null || _b === void 0 ? void 0 : _b.rawResponse.routes) !== null && _c !== void 0 ? _c : [];
+                if (routes.length === 0) {
+                    throw new Error(`${LOG_PREFIX} No routes returned from LiFi`);
+                }
+                const idx = (_d = params.routeIndex) !== null && _d !== void 0 ? _d : 0;
+                const route = routes[idx];
+                if (!route) {
+                    throw new Error(`${LOG_PREFIX} no route available at index ${idx}`);
+                }
+                (_e = params.onProgress) === null || _e === void 0 ? void 0 : _e.call(params, 'route_selected', { route, routeIndex: idx });
+                const hashes = [];
+                const stepsOut = [];
+                const totalSteps = route.steps.length;
+                for (let stepIndex = 0; stepIndex < route.steps.length; stepIndex++) {
+                    const step = route.steps[stepIndex];
+                    // Validate step exists (defensive check for sparse arrays)
+                    if (!step) {
+                        throw new Error(`${LOG_PREFIX} Step at index ${stepIndex} is undefined or null. This indicates a malformed route response.`);
+                    }
+                    (_f = params.onProgress) === null || _f === void 0 ? void 0 : _f.call(params, 'preparing_step', {
+                        route,
+                        routeIndex: idx,
+                        step,
+                        stepIndex,
+                        totalSteps,
+                    });
+                    const stepRes = yield this.getRouteStep(step);
+                    if (stepRes.error) {
+                        throw new Error(`${LOG_PREFIX} getRouteStep: ${stepRes.error}`);
+                    }
+                    const populated = (_g = stepRes.data) === null || _g === void 0 ? void 0 : _g.rawResponse;
+                    if (!populated) {
+                        throw new Error(`${LOG_PREFIX} getRouteStep returned no step data`);
+                    }
+                    const network = resolveLifiStepNetworkCaip2(populated);
+                    let tx = parseLifiTransactionRequestFromStep(populated);
+                    if (network.startsWith('eip155:')) {
+                        const stripped = (0, stripStalePlanningNonce_1.stripStalePlanningNonceIfJsonObject)(tx);
+                        // Validate stripped result is still an object
+                        if (typeof stripped !== 'object' ||
+                            stripped === null ||
+                            Array.isArray(stripped)) {
+                            throw new Error(`${LOG_PREFIX} stripStalePlanningNonce returned invalid type: ${typeof stripped}`);
+                        }
+                        tx = stripped;
+                    }
+                    (_h = params.onProgress) === null || _h === void 0 ? void 0 : _h.call(params, 'signing', {
+                        route,
+                        routeIndex: idx,
+                        step: populated,
+                        stepIndex,
+                        totalSteps,
+                        transaction: tx,
+                    });
+                    const txHash = yield signAndSend(tx, network);
+                    if (typeof txHash !== 'string' || txHash.trim().length === 0) {
+                        const msg = `Invalid transaction hash returned from signAndSendTransaction at step ${stepIndex} for network ${network}.`;
+                        (_j = params.onProgress) === null || _j === void 0 ? void 0 : _j.call(params, 'failed', {
+                            errorMessage: msg,
+                            txHash,
+                            routeIndex: idx,
+                            stepIndex,
+                            totalSteps,
+                            step: populated,
+                        });
+                        throw new LifiReportedError(`${LOG_PREFIX} ${msg}`);
+                    }
+                    hashes.push(txHash);
+                    (_k = params.onProgress) === null || _k === void 0 ? void 0 : _k.call(params, 'submitted', {
+                        route,
+                        routeIndex: idx,
+                        step: populated,
+                        stepIndex,
+                        totalSteps,
+                        txHash,
+                    });
+                    (_l = params.onProgress) === null || _l === void 0 ? void 0 : _l.call(params, 'confirming', {
+                        route,
+                        routeIndex: idx,
+                        step: populated,
+                        stepIndex,
+                        totalSteps,
+                        txHash,
+                    });
+                    const waiterResult = (yield effectiveWait(txHash, network));
+                    const ok = waiterResult === true;
+                    if (!ok) {
+                        const msg = `${LOG_PREFIX} on-chain confirmation did not complete (waitForConfirmation did not return true) for ${txHash} on ${network}`;
+                        (_m = params.onProgress) === null || _m === void 0 ? void 0 : _m.call(params, 'failed', {
+                            errorMessage: msg,
+                            txHash,
+                            routeIndex: idx,
+                            stepIndex,
+                            totalSteps,
+                            step: populated,
+                        });
+                        throw new LifiReportedError(msg);
+                    }
+                    const bridgeTool = statusBridgeFromStepTool(populated.tool);
+                    const crossLike = populated.type === 'cross' ||
+                        populated.action.fromChainId !== populated.action.toChainId;
+                    if (crossLike && bridgeTool) {
+                        (_o = params.onProgress) === null || _o === void 0 ? void 0 : _o.call(params, 'lifi_pending', {
+                            route,
+                            routeIndex: idx,
+                            step: populated,
+                            stepIndex,
+                            totalSteps,
+                            txHash,
+                        });
+                        const pollOpts = (_p = params.statusPoll) !== null && _p !== void 0 ? _p : {};
+                        const terminal = yield this.pollStatus({
+                            txHash,
+                            fromChain: params.fromChain,
+                            toChain: params.toChain,
+                            bridge: bridgeTool,
+                        }, pollOpts);
+                        (_q = params.onProgress) === null || _q === void 0 ? void 0 : _q.call(params, 'step_done', {
+                            route,
+                            routeIndex: idx,
+                            step: populated,
+                            stepIndex,
+                            totalSteps,
+                            txHash,
+                            lifiStatus: terminal,
+                        });
+                    }
+                    else {
+                        (_r = params.onProgress) === null || _r === void 0 ? void 0 : _r.call(params, 'step_done', {
+                            route,
+                            routeIndex: idx,
+                            step: populated,
+                            stepIndex,
+                            totalSteps,
+                            txHash,
+                        });
+                    }
+                    stepsOut.push(populated);
+                }
+                (_s = params.onProgress) === null || _s === void 0 ? void 0 : _s.call(params, 'complete', { route, routeIndex: idx });
+                return { hashes, steps: stepsOut, route };
+            }
+            catch (error) {
+                if (!(error instanceof LifiReportedError)) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    (_t = params.onProgress) === null || _t === void 0 ? void 0 : _t.call(params, 'failed', { errorMessage });
+                }
+                throw error;
+            }
+        });
+    }
 }
 exports.default = LiFi;