@portal-hq/web 3.13.1 → 3.13.2-0

package/lib/esm/integrations/delegations/index.test.js

@@ -85,4 +85,175 @@ describe('Delegations', () => {
             yield expect(delegations.transferFrom(mockTransferFromRequest)).rejects.toThrow('Test error');
         }));
     });
+    describe('approveAndSubmit, revokeAndSubmit, transferAndSubmit', () => {
+        const mockSignAndSend = jest.fn();
+        beforeEach(() => {
+            mockSignAndSend.mockResolvedValue('0xtxhash');
+        });
+        it('throws when signAndSendTransaction is not configured', () => __awaiter(void 0, void 0, void 0, function* () {
+            const d = new Delegations({ mpc });
+            yield expect(d.approveAndSubmit(mockEVMApproveRequest)).rejects.toThrow('[Delegations] No signer configured. Call setSignAndSendTransaction() on the instance or pass signAndSendTransaction in options.');
+            yield expect(d.revokeAndSubmit(mockEVMRevokeRequest)).rejects.toThrow('[Delegations] No signer configured. Call setSignAndSendTransaction() on the instance or pass signAndSendTransaction in options.');
+            yield expect(d.transferAndSubmit(mockTransferFromRequest)).rejects.toThrow('[Delegations] No signer configured. Call setSignAndSendTransaction() on the instance or pass signAndSendTransaction in options.');
+        }));
+        it('approveAndSubmit calls MPC then signAndSend per transaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse);
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            const result = yield d.approveAndSubmit(mockEVMApproveRequest);
+            expect(mpc.delegationsApprove).toHaveBeenCalledWith(mockEVMApproveRequest);
+            expect(mockSignAndSend).toHaveBeenCalledTimes(1);
+            expect(mockSignAndSend).toHaveBeenCalledWith(mockEVMApproveResponse.transactions[0], mockEVMApproveRequest.chain);
+            expect(result).toEqual({ hashes: ['0xtxhash'] });
+        }));
+        it('revokeAndSubmit calls delegationsRevoke then signAndSend per transaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(mpc, 'delegationsRevoke').mockResolvedValue(mockEVMRevokeResponse);
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            const result = yield d.revokeAndSubmit(mockEVMRevokeRequest);
+            expect(mpc.delegationsRevoke).toHaveBeenCalledWith(mockEVMRevokeRequest);
+            expect(mockSignAndSend).toHaveBeenCalledTimes(1);
+            expect(mockSignAndSend).toHaveBeenCalledWith(mockEVMRevokeResponse.transactions[0], mockEVMRevokeRequest.chain);
+            expect(result).toEqual({ hashes: ['0xtxhash'] });
+        }));
+        it('transferAndSubmit calls delegationsTransferFrom then signAndSend per transaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest
+                .spyOn(mpc, 'delegationsTransferFrom')
+                .mockResolvedValue(mockTransferFromResponse);
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            const result = yield d.transferAndSubmit(mockTransferFromRequest);
+            expect(mpc.delegationsTransferFrom).toHaveBeenCalledWith(mockTransferFromRequest);
+            expect(mockSignAndSend).toHaveBeenCalledTimes(1);
+            expect(mockSignAndSend).toHaveBeenCalledWith(mockTransferFromResponse.transactions[0], mockTransferFromRequest.chain);
+            expect(result).toEqual({ hashes: ['0xtxhash'] });
+        }));
+        it('uses encodedTransactions when transactions is empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            const response = {
+                transactions: [],
+                encodedTransactions: ['solTxPayload'],
+                metadata: mockEVMApproveResponse.metadata,
+            };
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(response);
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            yield d.approveAndSubmit(mockEVMApproveRequest);
+            expect(mockSignAndSend).toHaveBeenCalledWith('solTxPayload', mockEVMApproveRequest.chain);
+        }));
+        it('invokes onProgress for each transaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse);
+            const onProgress = jest.fn();
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            yield d.approveAndSubmit(mockEVMApproveRequest, { onProgress });
+            expect(onProgress).toHaveBeenCalledTimes(2);
+            expect(onProgress).toHaveBeenNthCalledWith(1, {
+                step: 'signing',
+                index: 0,
+                total: 1,
+            });
+            expect(onProgress).toHaveBeenNthCalledWith(2, {
+                step: 'submitted',
+                index: 0,
+                total: 1,
+                hash: '0xtxhash',
+            });
+        }));
+        it('throws when response has no transactions', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue({
+                metadata: mockEVMApproveResponse.metadata,
+            });
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            yield expect(d.approveAndSubmit(mockEVMApproveRequest)).rejects.toThrow('No transactions in delegation response.');
+            expect(mockSignAndSend).not.toHaveBeenCalled();
+        }));
+        it('submits multiple EVM transactions in order', () => __awaiter(void 0, void 0, void 0, function* () {
+            const txA = Object.assign({}, mockEVMApproveResponse.transactions[0]);
+            const txB = Object.assign(Object.assign({}, txA), { data: '0xbbbb' });
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(Object.assign(Object.assign({}, mockEVMApproveResponse), { transactions: [txA, txB] }));
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            mockSignAndSend.mockResolvedValueOnce('0xh1').mockResolvedValueOnce('0xh2');
+            const result = yield d.approveAndSubmit(mockEVMApproveRequest);
+            expect(mockSignAndSend).toHaveBeenCalledTimes(2);
+            expect(mockSignAndSend).toHaveBeenNthCalledWith(1, txA, mockEVMApproveRequest.chain);
+            expect(mockSignAndSend).toHaveBeenNthCalledWith(2, txB, mockEVMApproveRequest.chain);
+            expect(result.hashes).toEqual(['0xh1', '0xh2']);
+        }));
+        it('propagates error after first tx succeeds (partial submit)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const txA = Object.assign({}, mockEVMApproveResponse.transactions[0]);
+            const txB = Object.assign(Object.assign({}, txA), { data: '0xbbbb' });
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(Object.assign(Object.assign({}, mockEVMApproveResponse), { transactions: [txA, txB] }));
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            mockSignAndSend
+                .mockResolvedValueOnce('0xh1')
+                .mockRejectedValueOnce(new Error('second tx failed'));
+            yield expect(d.approveAndSubmit(mockEVMApproveRequest)).rejects.toThrow('second tx failed');
+            expect(mockSignAndSend).toHaveBeenCalledTimes(2);
+        }));
+        it('per-call signAndSendTransaction overrides constructor signer', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse);
+            const instanceSigner = jest.fn().mockResolvedValue('0xinstance');
+            const perCallSigner = jest.fn().mockResolvedValue('0xpercall');
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: instanceSigner,
+            });
+            yield d.approveAndSubmit(mockEVMApproveRequest, {
+                signAndSendTransaction: perCallSigner,
+            });
+            expect(instanceSigner).not.toHaveBeenCalled();
+            expect(perCallSigner).toHaveBeenCalledTimes(1);
+        }));
+        it('throws on whitespace-only hash from signer', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse);
+            mockSignAndSend.mockResolvedValue('   ');
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            yield expect(d.approveAndSubmit(mockEVMApproveRequest)).rejects.toThrow('Invalid transaction hash');
+        }));
+        it('prefers transactions over encodedTransactions when both non-empty', () => __awaiter(void 0, void 0, void 0, function* () {
+            const evmTx = mockEVMApproveResponse.transactions[0];
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue({
+                transactions: [evmTx],
+                encodedTransactions: ['should-not-use'],
+                metadata: mockEVMApproveResponse.metadata,
+            });
+            const d = new Delegations({
+                mpc,
+                signAndSendTransaction: mockSignAndSend,
+            });
+            yield d.approveAndSubmit(mockEVMApproveRequest);
+            expect(mockSignAndSend).toHaveBeenCalledWith(evmTx, mockEVMApproveRequest.chain);
+        }));
+        it('setSignAndSendTransaction enables submit after construction', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(mpc, 'delegationsApprove').mockResolvedValue(mockEVMApproveResponse);
+            const d = new Delegations({ mpc });
+            const late = jest.fn().mockResolvedValue('0xlate');
+            d.setSignAndSendTransaction(late);
+            const result = yield d.approveAndSubmit(mockEVMApproveRequest);
+            expect(late).toHaveBeenCalledTimes(1);
+            expect(result).toEqual({ hashes: ['0xlate'] });
+        }));
+    });
 });

package/lib/esm/integrations/ramps/noah/index.test.js

@@ -62,7 +62,15 @@ describe('Noah', () => {
             destinationAddress: 'SoLAddr1111111111111111111111111111111111111',
         };
         const spy = jest.spyOn(mpc, 'initiatePayin').mockResolvedValue({
-            data: { payinId: 'p1', bankDetails: {} },
+            data: {
+                payinId: 'p1',
+                bankDetails: {
+                    paymentMethodId: 'pm-123',
+                    paymentMethodType: 'bank_account',
+                    accountNumber: '1234567890',
+                    network: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+                },
+            },
         });
         yield noah.initiatePayin(req);
         expect(spy).toHaveBeenCalledWith(req);
@@ -74,14 +82,14 @@ describe('Noah', () => {
             fiatCurrency: 'USD',
         };
         const spy = jest.spyOn(mpc, 'simulatePayin').mockResolvedValue({
-            data: {},
+            data: { fiatDepositId: 'deposit-123' },
         });
         yield noah.simulatePayin(sim);
         expect(spy).toHaveBeenCalledWith(sim);
     }));
     it('should call mpc.getPayoutCountries', () => __awaiter(void 0, void 0, void 0, function* () {
         const spy = jest.spyOn(mpc, 'getPayoutCountries').mockResolvedValue({
-            data: { countries: [] },
+            data: { countries: { US: ['USD'], MX: ['MXN', 'USD'] } },
         });
         yield noah.getPayoutCountries();
         expect(spy).toHaveBeenCalled();
@@ -94,7 +102,7 @@ describe('Noah', () => {
             fiatAmount: '10',
         };
         const spy = jest.spyOn(mpc, 'getPayoutChannels').mockResolvedValue({
-            data: [],
+            data: { items: [] },
         });
         yield noah.getPayoutChannels(req);
         expect(spy).toHaveBeenCalledWith(req);
@@ -102,7 +110,12 @@ describe('Noah', () => {
     it('should call mpc.getPayoutChannelForm', () => __awaiter(void 0, void 0, void 0, function* () {
         const spy = jest
             .spyOn(mpc, 'getPayoutChannelForm')
-            .mockResolvedValue({ data: {} });
+            .mockResolvedValue({
+            data: {
+                formSchema: { type: 'object', properties: {} },
+                formMetadata: { contentHash: 'abc123' },
+            },
+        });
         yield noah.getPayoutChannelForm('ch-1');
         expect(spy).toHaveBeenCalledWith('ch-1');
     }));

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

@@ -1,12 +1,23 @@
+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;
+};
 import ZeroX from './zero-x';
 import LiFi from './lifi';
 /**
- * This class is a container for the LiFi class.
- * In the future, Trading domain logic should be here.
+ * Trading integrations (LiFi, 0x).
  */
 export default class Trading {
-    constructor({ mpc }) {
-        this.lifi = new LiFi({ mpc });
-        this.zeroX = new ZeroX({ mpc });
+    constructor(_a) {
+        var { mpc } = _a, defaults = __rest(_a, ["mpc"]);
+        this.lifi = new LiFi(Object.assign({ mpc }, defaults));
+        this.zeroX = new ZeroX(Object.assign({ mpc }, defaults));
     }
 }

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

@@ -7,56 +7,323 @@ 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;
+};
+import { sdkLogger } from '../../../logger';
+import { waitForEvmTxConfirmation } from '../../../internal/waitForEvmTxConfirmation';
+import { stripStalePlanningNonceIfJsonObject } from '../../../internal/stripStalePlanningNonce';
+import { pollLifiStatusUntilTerminal, } from './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. */
+export 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;
+}
+export 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);
+}
+export 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;
+}
+export function statusBridgeFromStepTool(tool) {
+    if (!tool) {
+        return undefined;
+    }
+    return tool.toLowerCase();
+}
+function mergeLifiOptions(instance, perCall) {
+    return Object.assign(Object.assign({}, instance), perCall);
+}
 export default 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 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:')) {
+                            sdkLogger.warn(`${LOG_PREFIX} Cannot verify confirmation for non-EVM network ${network}. ` +
+                                'Provide waitForConfirmation or use Portal.waitForConfirmation.');
+                            return Promise.resolve(false);
+                        }
+                        return 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 = 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;
+            }
+        });
+    }
 }