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

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

@@ -280,6 +280,27 @@ class LiFi {
                         });
                         throw new LifiReportedError(msg);
                     }
+                    let lifiTxHash = txHash;
+                    if (network.startsWith('eip155:') && o.evmRequestFn) {
+                        try {
+                            const userOpReceipt = yield o.evmRequestFn('eth_getUserOperationReceipt', [txHash], network);
+                            if (userOpReceipt &&
+                                typeof userOpReceipt === 'object' &&
+                                'receipt' in userOpReceipt &&
+                                userOpReceipt.receipt &&
+                                typeof userOpReceipt.receipt === 'object' &&
+                                'transactionHash' in userOpReceipt.receipt) {
+                                const bundleHash = userOpReceipt.receipt.transactionHash;
+                                if (bundleHash && typeof bundleHash === 'string') {
+                                    lifiTxHash = bundleHash;
+                                    logger_1.sdkLogger.debug(`${LOG_PREFIX} Resolved AA bundle tx hash for LiFi: ${lifiTxHash}`);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            logger_1.sdkLogger.debug(`${LOG_PREFIX} Could not resolve bundle hash (likely EOA tx), using original hash`);
+                        }
+                    }
                     const bridgeTool = statusBridgeFromStepTool(populated.tool);
                     const crossLike = populated.type === 'cross' ||
                         populated.action.fromChainId !== populated.action.toChainId;
@@ -294,7 +315,7 @@ class LiFi {
                         });
                         const pollOpts = (_p = params.statusPoll) !== null && _p !== void 0 ? _p : {};
                         const terminal = yield this.pollStatus({
-                            txHash,
+                            txHash: lifiTxHash,
                             fromChain: params.fromChain,
                             toChain: params.toChain,
                             bridge: bridgeTool,

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

@@ -327,4 +327,112 @@ describe('YieldXyz high-level (deposit, withdraw, defaults)', () => {
         expect(r.chain).toBe('eip155:1');
         expect(r.token).toBe('ETH');
     }));
+    it('status=SUCCESS when no waitForConfirmation configured', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield yieldXyz.deposit({
+            yieldId: 'y',
+            amount: '1',
+            address: constants_1.mockAddress,
+        });
+        expect(r.status).toBe('SUCCESS');
+    }));
+    it('status=SUCCESS when all confirmations reach true', () => __awaiter(void 0, void 0, void 0, function* () {
+        const y = new yieldxyz_1.default({
+            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' },
+            },
+            {
+                id: 'tx2',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x2' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield y.deposit({ yieldId: 'y', amount: '1', address: constants_1.mockAddress });
+        expect(r.status).toBe('SUCCESS');
+        expect(r.hashes).toHaveLength(2);
+    }));
+    it('status=FAILED when first confirmation returns false', () => __awaiter(void 0, void 0, void 0, function* () {
+        const y = new yieldxyz_1.default({
+            mpc,
+            waitForConfirmation: jest.fn().mockResolvedValue(false),
+        });
+        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({});
+        const r = yield y.deposit({ yieldId: 'y', amount: '1', address: constants_1.mockAddress });
+        expect(r.status).toBe('FAILED');
+        expect(r.hashes).toEqual(['0xh']);
+    }));
+    it('status=PARTIAL_SUCCESS when first tx confirms but second fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        const waiter = jest
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false);
+        const y = new yieldxyz_1.default({
+            mpc,
+            waitForConfirmation: waiter,
+        });
+        const signer = jest
+            .fn()
+            .mockResolvedValueOnce('0xh1')
+            .mockResolvedValueOnce('0xh2');
+        y.setSignAndSendTransaction(signer);
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+            {
+                id: 'tx2',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x2' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield y.deposit({ yieldId: 'y', amount: '1', address: constants_1.mockAddress });
+        expect(r.status).toBe('PARTIAL_SUCCESS');
+        expect(r.hashes).toEqual(['0xh1', '0xh2']);
+        expect(signer).toHaveBeenCalledTimes(2);
+        expect(waiter).toHaveBeenCalledTimes(2);
+    }));
+    it('withdraw: status=FAILED when confirmation returns false', () => __awaiter(void 0, void 0, void 0, function* () {
+        const y = new yieldxyz_1.default({
+            mpc,
+            waitForConfirmation: jest.fn().mockResolvedValue(false),
+        });
+        y.setSignAndSendTransaction(jest.fn().mockResolvedValue('0xh'));
+        jest.spyOn(mpc, 'exitYieldXyzYield').mockResolvedValue(exitResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield y.withdraw({ yieldId: 'y', amount: '1', address: constants_1.mockAddress });
+        expect(r.status).toBe('FAILED');
+        expect(r.hashes).toEqual(['0xh']);
+    }));
 });

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

@@ -263,9 +263,10 @@ class YieldXyz {
                 const result = Object.assign(Object.assign({}, base), (resolvedChain !== undefined && resolvedToken !== undefined
                     ? { chain: resolvedChain, token: resolvedToken }
                     : {}));
-                logger_1.sdkLogger.info(`${LOG_PREFIX} deposit: success`, {
+                logger_1.sdkLogger.info(`${LOG_PREFIX} deposit: complete`, {
                     hashes: result.hashes,
                     yieldId: result.yieldId,
+                    status: result.status,
                     yieldOpportunityDetails: result.yieldOpportunityDetails,
                 });
                 return result;
@@ -310,9 +311,10 @@ class YieldXyz {
                 const result = Object.assign(Object.assign({}, base), (resolvedChain !== undefined && resolvedToken !== undefined
                     ? { chain: resolvedChain, token: resolvedToken }
                     : {}));
-                logger_1.sdkLogger.info(`${LOG_PREFIX} withdraw: success`, {
+                logger_1.sdkLogger.info(`${LOG_PREFIX} withdraw: complete`, {
                     hashes: result.hashes,
                     yieldId: result.yieldId,
+                    status: result.status,
                     yieldOpportunityDetails: result.yieldOpportunityDetails,
                 });
                 return result;
@@ -444,6 +446,7 @@ class YieldXyz {
             const total = transactions.length;
             const hashes = [];
             let confirmationsReached = 0;
+            let confirmationsRequired = waitForConfirmation ? total : 0;
             for (let index = 0; index < transactions.length; index++) {
                 const tx = transactions[index];
                 // Validate transaction exists (defensive check for sparse arrays)
@@ -615,15 +618,36 @@ class YieldXyz {
             const rawResponse = (_d = response.data) === null || _d === void 0 ? void 0 : _d.rawResponse;
             const yieldId = (_e = rawResponse === null || rawResponse === void 0 ? void 0 : rawResponse.yieldId) !== null && _e !== void 0 ? _e : '';
             const yieldOpportunityDetails = this.buildYieldOpportunityDetails(response);
+            // Determine status based on confirmation semantics from docs:
+            // - If no confirmations required (no waitForConfirmation): SUCCESS
+            // - If all required confirmations reached: SUCCESS
+            // - If some confirmations reached but not all: PARTIAL_SUCCESS
+            // - If confirmations required but zero reached: FAILED
+            let status;
+            if (confirmationsRequired === 0) {
+                status = 'SUCCESS';
+            }
+            else if (confirmationsReached === confirmationsRequired) {
+                status = 'SUCCESS';
+            }
+            else if (confirmationsReached > 0) {
+                status = 'PARTIAL_SUCCESS';
+            }
+            else {
+                status = 'FAILED';
+            }
             logger_1.sdkLogger.info(`${LOG_PREFIX} ${method}: executeAndTrack complete`, {
                 yieldId,
                 hashCount: hashes.length,
-                confirmationsReached: confirmationsReached > 0 ? confirmationsReached : undefined,
+                confirmationsReached,
+                confirmationsRequired,
+                status,
             });
             return {
                 hashes,
                 yieldId,
                 yieldOpportunityDetails,
+                status,
             };
         });
     }

package/lib/commonjs/mpc/index.js

@@ -14,7 +14,7 @@ const errors_1 = require("./errors");
 const logger_1 = require("../logger");
 const index_1 = require("../index");
 const trace_1 = require("../shared/trace");
-const WEB_SDK_VERSION = '3.14.0-alpha.0';
+const WEB_SDK_VERSION = '3.14.0';
 class Mpc {
     get ready() {
         return this._ready;
@@ -1011,10 +1011,11 @@ class Mpc {
         });
     }
     rpcRequest(data, options) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const { timeoutMs = 30000, traceId } = options !== null && options !== void 0 ? options : {};
-            const requestId = (_b = (_a = crypto.randomUUID) === null || _a === void 0 ? void 0 : _a.call(crypto)) !== null && _b !== void 0 ? _b : `${Date.now()}-${Math.random()}`;
+            const requestId = typeof crypto !== 'undefined' && crypto.randomUUID
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random()}`;
             const resolvedTraceId = traceId !== null && traceId !== void 0 ? traceId : (0, trace_1.generateTraceId)();
             logger_1.sdkLogger.debug('[Portal] rpcRequest', {
                 requestId,

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

@@ -273,6 +273,27 @@ export default class LiFi {
                         });
                         throw new LifiReportedError(msg);
                     }
+                    let lifiTxHash = txHash;
+                    if (network.startsWith('eip155:') && o.evmRequestFn) {
+                        try {
+                            const userOpReceipt = yield o.evmRequestFn('eth_getUserOperationReceipt', [txHash], network);
+                            if (userOpReceipt &&
+                                typeof userOpReceipt === 'object' &&
+                                'receipt' in userOpReceipt &&
+                                userOpReceipt.receipt &&
+                                typeof userOpReceipt.receipt === 'object' &&
+                                'transactionHash' in userOpReceipt.receipt) {
+                                const bundleHash = userOpReceipt.receipt.transactionHash;
+                                if (bundleHash && typeof bundleHash === 'string') {
+                                    lifiTxHash = bundleHash;
+                                    sdkLogger.debug(`${LOG_PREFIX} Resolved AA bundle tx hash for LiFi: ${lifiTxHash}`);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            sdkLogger.debug(`${LOG_PREFIX} Could not resolve bundle hash (likely EOA tx), using original hash`);
+                        }
+                    }
                     const bridgeTool = statusBridgeFromStepTool(populated.tool);
                     const crossLike = populated.type === 'cross' ||
                         populated.action.fromChainId !== populated.action.toChainId;
@@ -287,7 +308,7 @@ export default class LiFi {
                         });
                         const pollOpts = (_p = params.statusPoll) !== null && _p !== void 0 ? _p : {};
                         const terminal = yield this.pollStatus({
-                            txHash,
+                            txHash: lifiTxHash,
                             fromChain: params.fromChain,
                             toChain: params.toChain,
                             bridge: bridgeTool,

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

@@ -322,4 +322,112 @@ describe('YieldXyz high-level (deposit, withdraw, defaults)', () => {
         expect(r.chain).toBe('eip155:1');
         expect(r.token).toBe('ETH');
     }));
+    it('status=SUCCESS when no waitForConfirmation configured', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield yieldXyz.deposit({
+            yieldId: 'y',
+            amount: '1',
+            address: mockAddress,
+        });
+        expect(r.status).toBe('SUCCESS');
+    }));
+    it('status=SUCCESS when all confirmations reach true', () => __awaiter(void 0, void 0, void 0, function* () {
+        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' },
+            },
+            {
+                id: 'tx2',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x2' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield y.deposit({ yieldId: 'y', amount: '1', address: mockAddress });
+        expect(r.status).toBe('SUCCESS');
+        expect(r.hashes).toHaveLength(2);
+    }));
+    it('status=FAILED when first confirmation returns false', () => __awaiter(void 0, void 0, void 0, function* () {
+        const y = new YieldXyz({
+            mpc,
+            waitForConfirmation: jest.fn().mockResolvedValue(false),
+        });
+        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({});
+        const r = yield y.deposit({ yieldId: 'y', amount: '1', address: mockAddress });
+        expect(r.status).toBe('FAILED');
+        expect(r.hashes).toEqual(['0xh']);
+    }));
+    it('status=PARTIAL_SUCCESS when first tx confirms but second fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        const waiter = jest
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false);
+        const y = new YieldXyz({
+            mpc,
+            waitForConfirmation: waiter,
+        });
+        const signer = jest
+            .fn()
+            .mockResolvedValueOnce('0xh1')
+            .mockResolvedValueOnce('0xh2');
+        y.setSignAndSendTransaction(signer);
+        jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(enterResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+            {
+                id: 'tx2',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x2' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield y.deposit({ yieldId: 'y', amount: '1', address: mockAddress });
+        expect(r.status).toBe('PARTIAL_SUCCESS');
+        expect(r.hashes).toEqual(['0xh1', '0xh2']);
+        expect(signer).toHaveBeenCalledTimes(2);
+        expect(waiter).toHaveBeenCalledTimes(2);
+    }));
+    it('withdraw: status=FAILED when confirmation returns false', () => __awaiter(void 0, void 0, void 0, function* () {
+        const y = new YieldXyz({
+            mpc,
+            waitForConfirmation: jest.fn().mockResolvedValue(false),
+        });
+        y.setSignAndSendTransaction(jest.fn().mockResolvedValue('0xh'));
+        jest.spyOn(mpc, 'exitYieldXyzYield').mockResolvedValue(exitResponseWithTxs([
+            {
+                id: 'tx1',
+                network: 'eip155:1',
+                unsignedTransaction: { to: '0x1' },
+            },
+        ]));
+        jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({});
+        const r = yield y.withdraw({ yieldId: 'y', amount: '1', address: mockAddress });
+        expect(r.status).toBe('FAILED');
+        expect(r.hashes).toEqual(['0xh']);
+    }));
 });

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

@@ -261,9 +261,10 @@ export default class YieldXyz {
                 const result = Object.assign(Object.assign({}, base), (resolvedChain !== undefined && resolvedToken !== undefined
                     ? { chain: resolvedChain, token: resolvedToken }
                     : {}));
-                sdkLogger.info(`${LOG_PREFIX} deposit: success`, {
+                sdkLogger.info(`${LOG_PREFIX} deposit: complete`, {
                     hashes: result.hashes,
                     yieldId: result.yieldId,
+                    status: result.status,
                     yieldOpportunityDetails: result.yieldOpportunityDetails,
                 });
                 return result;
@@ -308,9 +309,10 @@ export default class YieldXyz {
                 const result = Object.assign(Object.assign({}, base), (resolvedChain !== undefined && resolvedToken !== undefined
                     ? { chain: resolvedChain, token: resolvedToken }
                     : {}));
-                sdkLogger.info(`${LOG_PREFIX} withdraw: success`, {
+                sdkLogger.info(`${LOG_PREFIX} withdraw: complete`, {
                     hashes: result.hashes,
                     yieldId: result.yieldId,
+                    status: result.status,
                     yieldOpportunityDetails: result.yieldOpportunityDetails,
                 });
                 return result;
@@ -442,6 +444,7 @@ export default class YieldXyz {
             const total = transactions.length;
             const hashes = [];
             let confirmationsReached = 0;
+            let confirmationsRequired = waitForConfirmation ? total : 0;
             for (let index = 0; index < transactions.length; index++) {
                 const tx = transactions[index];
                 // Validate transaction exists (defensive check for sparse arrays)
@@ -613,15 +616,36 @@ export default class YieldXyz {
             const rawResponse = (_d = response.data) === null || _d === void 0 ? void 0 : _d.rawResponse;
             const yieldId = (_e = rawResponse === null || rawResponse === void 0 ? void 0 : rawResponse.yieldId) !== null && _e !== void 0 ? _e : '';
             const yieldOpportunityDetails = this.buildYieldOpportunityDetails(response);
+            // Determine status based on confirmation semantics from docs:
+            // - If no confirmations required (no waitForConfirmation): SUCCESS
+            // - If all required confirmations reached: SUCCESS
+            // - If some confirmations reached but not all: PARTIAL_SUCCESS
+            // - If confirmations required but zero reached: FAILED
+            let status;
+            if (confirmationsRequired === 0) {
+                status = 'SUCCESS';
+            }
+            else if (confirmationsReached === confirmationsRequired) {
+                status = 'SUCCESS';
+            }
+            else if (confirmationsReached > 0) {
+                status = 'PARTIAL_SUCCESS';
+            }
+            else {
+                status = 'FAILED';
+            }
             sdkLogger.info(`${LOG_PREFIX} ${method}: executeAndTrack complete`, {
                 yieldId,
                 hashCount: hashes.length,
-                confirmationsReached: confirmationsReached > 0 ? confirmationsReached : undefined,
+                confirmationsReached,
+                confirmationsRequired,
+                status,
             });
             return {
                 hashes,
                 yieldId,
                 yieldOpportunityDetails,
+                status,
             };
         });
     }

package/lib/esm/mpc/index.js

@@ -11,7 +11,7 @@ import { PortalMpcError } from './errors';
 import { sdkLogger } from '../logger';
 import { BackupMethods, } from '../index';
 import { generateTraceId } from '../shared/trace';
-const WEB_SDK_VERSION = '3.14.0-alpha.0';
+const WEB_SDK_VERSION = '3.14.0';
 class Mpc {
     get ready() {
         return this._ready;
@@ -1008,10 +1008,11 @@ class Mpc {
         });
     }
     rpcRequest(data, options) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const { timeoutMs = 30000, traceId } = options !== null && options !== void 0 ? options : {};
-            const requestId = (_b = (_a = crypto.randomUUID) === null || _a === void 0 ? void 0 : _a.call(crypto)) !== null && _b !== void 0 ? _b : `${Date.now()}-${Math.random()}`;
+            const requestId = typeof crypto !== 'undefined' && crypto.randomUUID
+                ? crypto.randomUUID()
+                : `${Date.now()}-${Math.random()}`;
             const resolvedTraceId = traceId !== null && traceId !== void 0 ? traceId : generateTraceId();
             sdkLogger.debug('[Portal] rpcRequest', {
                 requestId,

package/package.json

@@ -3,7 +3,7 @@
   "description": "Portal MPC Support for Web",
   "author": "Portal Labs, Inc.",
   "homepage": "https://portalhq.io/",
-  "version": "3.14.0-alpha.0",
+  "version": "3.14.0",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",
@@ -58,6 +58,5 @@
   },
   "dependencies": {
     "@solana/web3.js": "^1.91.8"
-  },
-  "stableVersion": "3.13.1"
+  }
 }

package/src/integrations/trading/lifi/index.ts

@@ -358,6 +358,39 @@ export default class LiFi implements ILiFi {
           throw new LifiReportedError(msg)
         }
 
+        let lifiTxHash = txHash
+        if (network.startsWith('eip155:') && o.evmRequestFn) {
+          try {
+            const userOpReceipt = await o.evmRequestFn(
+              'eth_getUserOperationReceipt',
+              [txHash],
+              network,
+            )
+            if (
+              userOpReceipt &&
+              typeof userOpReceipt === 'object' &&
+              'receipt' in userOpReceipt &&
+              userOpReceipt.receipt &&
+              typeof userOpReceipt.receipt === 'object' &&
+              'transactionHash' in userOpReceipt.receipt
+            ) {
+              const bundleHash = (
+                userOpReceipt.receipt as { transactionHash?: string }
+              ).transactionHash
+              if (bundleHash && typeof bundleHash === 'string') {
+                lifiTxHash = bundleHash
+                sdkLogger.debug(
+                  `${LOG_PREFIX} Resolved AA bundle tx hash for LiFi: ${lifiTxHash}`,
+                )
+              }
+            }
+          } catch (error) {
+            sdkLogger.debug(
+              `${LOG_PREFIX} Could not resolve bundle hash (likely EOA tx), using original hash`,
+            )
+          }
+        }
+
         const bridgeTool = statusBridgeFromStepTool(populated.tool)
         const crossLike =
           populated.type === 'cross' ||
@@ -376,7 +409,7 @@ export default class LiFi implements ILiFi {
           const pollOpts = params.statusPoll ?? {}
           const terminal = await this.pollStatus(
             {
-              txHash,
+              txHash: lifiTxHash,
               fromChain: params.fromChain,
               toChain: params.toChain,
               bridge: bridgeTool,

package/src/integrations/yield/yieldxyz.highLevel.test.ts

@@ -400,4 +400,137 @@ describe('YieldXyz high-level (deposit, withdraw, defaults)', () => {
     expect(r.chain).toBe('eip155:1')
     expect(r.token).toBe('ETH')
   })
+
+  it('status=SUCCESS when no waitForConfirmation configured', async () => {
+    jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(
+      enterResponseWithTxs([
+        {
+          id: 'tx1',
+          network: 'eip155:1',
+          unsignedTransaction: { to: '0x1' },
+        },
+      ]),
+    )
+    jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({})
+
+    const r = await yieldXyz.deposit({
+      yieldId: 'y',
+      amount: '1',
+      address: mockAddress,
+    })
+
+    expect(r.status).toBe('SUCCESS')
+  })
+
+  it('status=SUCCESS when all confirmations reach true', async () => {
+    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' },
+        },
+        {
+          id: 'tx2',
+          network: 'eip155:1',
+          unsignedTransaction: { to: '0x2' },
+        },
+      ]),
+    )
+    jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({})
+
+    const r = await y.deposit({ yieldId: 'y', amount: '1', address: mockAddress })
+
+    expect(r.status).toBe('SUCCESS')
+    expect(r.hashes).toHaveLength(2)
+  })
+
+  it('status=FAILED when first confirmation returns false', async () => {
+    const y = new YieldXyz({
+      mpc,
+      waitForConfirmation: jest.fn().mockResolvedValue(false),
+    })
+    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({})
+
+    const r = await y.deposit({ yieldId: 'y', amount: '1', address: mockAddress })
+
+    expect(r.status).toBe('FAILED')
+    expect(r.hashes).toEqual(['0xh'])
+  })
+
+  it('status=PARTIAL_SUCCESS when first tx confirms but second fails', async () => {
+    const waiter = jest
+      .fn()
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false)
+    const y = new YieldXyz({
+      mpc,
+      waitForConfirmation: waiter,
+    })
+    const signer = jest
+      .fn()
+      .mockResolvedValueOnce('0xh1')
+      .mockResolvedValueOnce('0xh2')
+    y.setSignAndSendTransaction(signer)
+    jest.spyOn(mpc, 'enterYieldXyzYield').mockResolvedValue(
+      enterResponseWithTxs([
+        {
+          id: 'tx1',
+          network: 'eip155:1',
+          unsignedTransaction: { to: '0x1' },
+        },
+        {
+          id: 'tx2',
+          network: 'eip155:1',
+          unsignedTransaction: { to: '0x2' },
+        },
+      ]),
+    )
+    jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({})
+
+    const r = await y.deposit({ yieldId: 'y', amount: '1', address: mockAddress })
+
+    expect(r.status).toBe('PARTIAL_SUCCESS')
+    expect(r.hashes).toEqual(['0xh1', '0xh2'])
+    expect(signer).toHaveBeenCalledTimes(2)
+    expect(waiter).toHaveBeenCalledTimes(2)
+  })
+
+  it('withdraw: status=FAILED when confirmation returns false', async () => {
+    const y = new YieldXyz({
+      mpc,
+      waitForConfirmation: jest.fn().mockResolvedValue(false),
+    })
+    y.setSignAndSendTransaction(jest.fn().mockResolvedValue('0xh'))
+    jest.spyOn(mpc, 'exitYieldXyzYield').mockResolvedValue(
+      exitResponseWithTxs([
+        {
+          id: 'tx1',
+          network: 'eip155:1',
+          unsignedTransaction: { to: '0x1' },
+        },
+      ]),
+    )
+    jest.spyOn(mpc, 'trackYieldXyzTransaction').mockResolvedValue({})
+
+    const r = await y.withdraw({ yieldId: 'y', amount: '1', address: mockAddress })
+
+    expect(r.status).toBe('FAILED')
+    expect(r.hashes).toEqual(['0xh'])
+  })
 })

package/src/integrations/yield/yieldxyz.ts

@@ -11,6 +11,7 @@ import type {
   YieldDepositResult,
   YieldSubmitOptions,
   YieldSubmitProgress,
+  YieldSubmitResultStatus,
   YieldWithdrawParams,
   YieldWithdrawResult,
   YieldXyzActionTransaction,
@@ -369,9 +370,10 @@ export default class YieldXyz {
           : {}),
       }
 
-      sdkLogger.info(`${LOG_PREFIX} deposit: success`, {
+      sdkLogger.info(`${LOG_PREFIX} deposit: complete`, {
         hashes: result.hashes,
         yieldId: result.yieldId,
+        status: result.status,
         yieldOpportunityDetails: result.yieldOpportunityDetails,
       })
       return result
@@ -439,9 +441,10 @@ export default class YieldXyz {
           : {}),
       }
 
-      sdkLogger.info(`${LOG_PREFIX} withdraw: success`, {
+      sdkLogger.info(`${LOG_PREFIX} withdraw: complete`, {
         hashes: result.hashes,
         yieldId: result.yieldId,
+        status: result.status,
         yieldOpportunityDetails: result.yieldOpportunityDetails,
       })
       return result
@@ -600,7 +603,7 @@ export default class YieldXyz {
   ): Promise<
     Pick<
       YieldDepositResult,
-      'hashes' | 'yieldId' | 'yieldOpportunityDetails'
+      'hashes' | 'yieldId' | 'yieldOpportunityDetails' | 'status'
     >
   > {
     const transactions = this.extractTransactions(response)
@@ -617,6 +620,7 @@ export default class YieldXyz {
     const total = transactions.length
     const hashes: string[] = []
     let confirmationsReached = 0
+    let confirmationsRequired = waitForConfirmation ? total : 0
 
     for (let index = 0; index < transactions.length; index++) {
       const tx = transactions[index]
@@ -838,17 +842,35 @@ export default class YieldXyz {
     const yieldId = rawResponse?.yieldId ?? ''
     const yieldOpportunityDetails = this.buildYieldOpportunityDetails(response)
 
+    // Determine status based on confirmation semantics from docs:
+    // - If no confirmations required (no waitForConfirmation): SUCCESS
+    // - If all required confirmations reached: SUCCESS
+    // - If some confirmations reached but not all: PARTIAL_SUCCESS
+    // - If confirmations required but zero reached: FAILED
+    let status: YieldSubmitResultStatus
+    if (confirmationsRequired === 0) {
+      status = 'SUCCESS'
+    } else if (confirmationsReached === confirmationsRequired) {
+      status = 'SUCCESS'
+    } else if (confirmationsReached > 0) {
+      status = 'PARTIAL_SUCCESS'
+    } else {
+      status = 'FAILED'
+    }
+
     sdkLogger.info(`${LOG_PREFIX} ${method}: executeAndTrack complete`, {
       yieldId,
       hashCount: hashes.length,
-      confirmationsReached:
-        confirmationsReached > 0 ? confirmationsReached : undefined,
+      confirmationsReached,
+      confirmationsRequired,
+      status,
     })
 
     return {
       hashes,
       yieldId,
       yieldOpportunityDetails,
+      status,
     }
   }
 }

package/src/mpc/index.ts

@@ -134,7 +134,7 @@ import {
 } from '../../hypernative'
 import { generateTraceId } from '../shared/trace'
 
-const WEB_SDK_VERSION = '3.14.0-alpha.0'
+const WEB_SDK_VERSION = '3.14.0'
 
 class Mpc {
   public iframe?: HTMLIFrameElement
@@ -1288,7 +1288,9 @@ class Mpc {
   ): Promise<RpcProxyResponse> {
     const { timeoutMs = 30_000, traceId } = options ?? {}
     const requestId =
-      crypto.randomUUID?.() ?? `${Date.now()}-${Math.random()}`
+      typeof crypto !== 'undefined' && crypto.randomUUID
+        ? crypto.randomUUID()
+        : `${Date.now()}-${Math.random()}`
     const resolvedTraceId = traceId ?? generateTraceId()
 
     sdkLogger.debug('[Portal] rpcRequest', {

package/src/shared/types/yieldxyz.ts

@@ -877,6 +877,11 @@ export type YieldDepositParams =
  */
 export type YieldWithdrawParams = YieldDepositParams
 
+/**
+ * Result status for deposit/withdraw operations
+ */
+export type YieldSubmitResultStatus = 'SUCCESS' | 'PARTIAL_SUCCESS' | 'FAILED'
+
 /**
  * Options for deposit/withdraw high-level methods (e.g. onProgress).
  */
@@ -933,6 +938,7 @@ export interface YieldDepositResult {
   yieldId: string
   chain?: string
   token?: string
+  status: YieldSubmitResultStatus
   yieldOpportunityDetails: {
     yieldId: string
     intent?: YieldXyzActionIntent
@@ -952,6 +958,7 @@ export interface YieldWithdrawResult {
   yieldId: string
   chain?: string
   token?: string
+  status: YieldSubmitResultStatus
   yieldOpportunityDetails: {
     yieldId: string
     intent?: YieldXyzActionIntent

package/src/shared/types/zero-x.ts

@@ -14,9 +14,9 @@ export interface ZeroExQuoteRequest {
   sellEntireBalance?: 'true' | 'false'
 }
 
-export interface ZeroExQuoteResponse {
+interface ZeroExQuoteSuccess {
   /** When set (non-empty after trim), do not execute the quote (fail closed). */
-  error?: string
+  error?: never
   data: {
     rawResponse: {
       message?: string
@@ -96,6 +96,22 @@ export interface ZeroExQuoteResponse {
   }
 }
 
+interface ZeroExQuoteError {
+  /** When set (non-empty after trim), do not execute the quote (fail closed). */
+  error: string
+  data?: never
+  metadata?: {
+    buyToken: string
+    sellToken: string
+    sellAmount: string
+    chainId: string
+    clientId: string
+    clientEip155Address: string
+  }
+}
+
+export type ZeroExQuoteResponse = ZeroExQuoteSuccess | ZeroExQuoteError
+
 export interface ZeroExSourcesRequest {
   chainId: string
 }