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

package/lib/commonjs/index.js

@@ -316,6 +316,9 @@ class Portal {
             yield this.storedClientBackupShare(true, BackupMethods.passkey);
         });
     }
+    configureFirebaseStorage(options) {
+        this.mpc.configureFirebaseStorage(options);
+    }
     backupWallet(backupMethod, progress = () => {
         // Noop
     }, backupConfigs = {}) {
@@ -1144,6 +1147,7 @@ var BackupMethods;
     BackupMethods["password"] = "PASSWORD";
     BackupMethods["passkey"] = "PASSKEY";
     BackupMethods["custom"] = "CUSTOM";
+    BackupMethods["firebase"] = "FIREBASE";
     BackupMethods["unknown"] = "UNKNOWN";
 })(BackupMethods = exports.BackupMethods || (exports.BackupMethods = {}));
 var GetTransactionsOrder;

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.15.0-alpha.2';
 class Mpc {
     get ready() {
         return this._ready;
@@ -25,6 +25,47 @@ class Mpc {
     constructor({ portal }) {
         this._ready = false;
         this.presignatureLogHandler = null;
+        this.boundFirebaseTokenBridge = (event) => {
+            var _a;
+            const { origin } = event;
+            if (origin !== this.getOrigin()) {
+                return;
+            }
+            if (event.source !== ((_a = this.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow)) {
+                return;
+            }
+            const { type, data } = event.data || {};
+            if (type !== 'portal:firebase:requestToken') {
+                return;
+            }
+            const requestId = data === null || data === void 0 ? void 0 : data.requestId;
+            if (!requestId) {
+                return;
+            }
+            const getter = this.firebaseGetToken;
+            void (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (!getter) {
+                        throw new Error('Firebase storage is not configured (getToken missing)');
+                    }
+                    const token = yield getter({
+                        forceRefresh: (data === null || data === void 0 ? void 0 : data.forceRefresh) === true,
+                    });
+                    this.postMessage({
+                        type: 'portal:firebase:requestTokenResult',
+                        data: { requestId, token },
+                    });
+                }
+                catch (e) {
+                    const message = (e instanceof Error ? e.message : String(e)) ||
+                        'Unknown firebase token error';
+                    this.postMessage({
+                        type: 'portal:firebase:requestTokenError',
+                        data: { requestId, message },
+                    });
+                }
+            }))();
+        };
         this.configureIframe = () => {
             const config = {
                 apiKey: this.portal.apiKey,
@@ -54,6 +95,14 @@ class Mpc {
         this.configureIframe = this.configureIframe.bind(this);
         // Create the iFrame for MPC operations
         this.appendIframe();
+        window.addEventListener('message', this.boundFirebaseTokenBridge);
+    }
+    configureFirebaseStorage(options) {
+        this.firebaseGetToken = options.getToken;
+        this.postMessage({
+            type: 'portal:firebase:configure',
+            data: { tbsHost: options.tbsHost },
+        });
     }
     /*******************************
      * Wallet Methods
@@ -1011,10 +1060,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/commonjs/mpc/index.test.js

@@ -30,6 +30,53 @@ describe('Mpc', () => {
             portal: portal_1.default,
         });
     });
+    describe('configureFirebaseStorage', () => {
+        it('posts configure to iframe and bridges token requests from iframe', () => __awaiter(void 0, void 0, void 0, function* () {
+            const postSpy = jest
+                .spyOn(mpc.iframe.contentWindow, 'postMessage')
+                .mockImplementation(() => { });
+            mpc.configureFirebaseStorage({
+                getToken: (opts) => __awaiter(void 0, void 0, void 0, function* () { return (opts === null || opts === void 0 ? void 0 : opts.forceRefresh) ? 'firebase-jwt-refreshed' : 'firebase-jwt'; }),
+                tbsHost: 'backup.web.portalhq.io',
+            });
+            expect(postSpy).toHaveBeenNthCalledWith(1, {
+                type: 'portal:firebase:configure',
+                data: { tbsHost: 'backup.web.portalhq.io' },
+            }, mockHostOrigin);
+            const bridge = mpc
+                .boundFirebaseTokenBridge;
+            bridge(new MessageEvent('message', {
+                origin: mockHostOrigin,
+                source: mpc.iframe.contentWindow,
+                data: {
+                    type: 'portal:firebase:requestToken',
+                    data: { requestId: 'r1' },
+                },
+            }));
+            yield new Promise((resolve) => {
+                setTimeout(resolve, 0);
+            });
+            expect(postSpy).toHaveBeenNthCalledWith(2, {
+                type: 'portal:firebase:requestTokenResult',
+                data: { requestId: 'r1', token: 'firebase-jwt' },
+            }, mockHostOrigin);
+            bridge(new MessageEvent('message', {
+                origin: mockHostOrigin,
+                source: mpc.iframe.contentWindow,
+                data: {
+                    type: 'portal:firebase:requestToken',
+                    data: { requestId: 'r2', forceRefresh: true },
+                },
+            }));
+            yield new Promise((resolve) => {
+                setTimeout(resolve, 0);
+            });
+            expect(postSpy).toHaveBeenNthCalledWith(3, {
+                type: 'portal:firebase:requestTokenResult',
+                data: { requestId: 'r2', token: 'firebase-jwt-refreshed' },
+            }, mockHostOrigin);
+        }));
+    });
     describe('backup', () => {
         const args = {
             backupMethod: index_1.BackupMethods.password,
@@ -267,7 +314,7 @@ describe('Mpc', () => {
             })
                 .catch((e) => {
                 expect(e).toBeInstanceOf(Error);
-                expect(e.message).toEqual('Invalid backup method: INVALID_METHOD. Valid methods are: GDRIVE, PASSWORD, PASSKEY, CUSTOM, UNKNOWN');
+                expect(e.message).toEqual('Invalid backup method: INVALID_METHOD. Valid methods are: GDRIVE, PASSWORD, PASSKEY, CUSTOM, FIREBASE, UNKNOWN');
                 done();
             });
         });

package/lib/commonjs/provider/index.js

@@ -58,6 +58,7 @@ var RequestMethod;
     RequestMethod["eth_sendTransaction"] = "eth_sendTransaction";
     RequestMethod["eth_sign"] = "eth_sign";
     RequestMethod["eth_signTransaction"] = "eth_signTransaction";
+    RequestMethod["eth_signUserOperation"] = "eth_signUserOperation";
     RequestMethod["eth_signTypedData"] = "eth_signTypedData";
     RequestMethod["eth_signTypedData_v3"] = "eth_signTypedData_v3";
     RequestMethod["eth_signTypedData_v4"] = "eth_signTypedData_v4";
@@ -144,6 +145,7 @@ const signerMethods = [
     RequestMethod.eth_sendTransaction,
     RequestMethod.eth_sign,
     RequestMethod.eth_signTransaction,
+    RequestMethod.eth_signUserOperation,
     RequestMethod.eth_signTypedData_v3,
     RequestMethod.eth_signTypedData_v4,
     RequestMethod.personal_sign,
@@ -447,6 +449,7 @@ class Provider {
                 case RequestMethod.eth_sendTransaction:
                 case RequestMethod.eth_sign:
                 case RequestMethod.eth_signTransaction:
+                case RequestMethod.eth_signUserOperation:
                 case RequestMethod.eth_signTypedData_v3:
                 case RequestMethod.eth_signTypedData_v4:
                 case RequestMethod.personal_sign: {

package/lib/commonjs/provider/index.test.js

@@ -206,6 +206,53 @@ describe('Provider', () => {
                     });
                 }));
             });
+            describe('eth_signUserOperation', () => {
+                const mockUserOperation = {
+                    sender: '0x1234567890123456789012345678901234567890',
+                    callData: '0x',
+                    nonce: '0x0',
+                    maxFeePerGas: '0x3B9ACA00',
+                    maxPriorityFeePerGas: '0x3B9ACA00',
+                    signature: '0x',
+                };
+                it('should throw an error if no chainId is provided alongside eth_signUserOperation', () => __awaiter(void 0, void 0, void 0, function* () {
+                    expect(provider.request({
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                    })).rejects.toThrow(new Error(`[PortalProvider] Chain ID is required for the operation`));
+                }));
+                it('should throw an error if malformed chainId is provided alongside eth_signUserOperation', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    expect(provider.request({
+                        chainId,
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                    })).rejects.toThrow(new Error(`[PortalProvider] Chain ID must be prefixed with "eip155:" for the operation, got ${chainId}`));
+                }));
+                it('should successfully handle an eth_signUserOperation request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: mockUserOperation,
+                        rpcUrl: constants_1.mockRpcUrl,
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                        signature: result,
+                    });
+                }));
+            });
             describe('eth_sign', () => {
                 it('should throw an error if no chainId is provided alongside eth_sign', () => __awaiter(void 0, void 0, void 0, function* () {
                     expect(provider.request({
@@ -674,6 +721,69 @@ describe('Provider', () => {
                     expect(mockConsoleWarn).toHaveBeenCalledWith("[PortalProvider] Request for signing method 'eth_signTransaction' could not be completed because it was not approved by the user.");
                 }));
             });
+            describe('eth_signUserOperation', () => {
+                const mockUserOperation = {
+                    sender: '0x1234567890123456789012345678901234567890',
+                    callData: '0x',
+                    nonce: '0x0',
+                    maxFeePerGas: '0x3B9ACA00',
+                    maxPriorityFeePerGas: '0x3B9ACA00',
+                    signature: '0x',
+                };
+                it('should successfully handle an approved eth_signUserOperation request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.eth_signUserOperation,
+                            params: [mockUserOperation],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: mockUserOperation,
+                        rpcUrl: constants_1.mockRpcUrl,
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected eth_signUserOperation request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.eth_signUserOperation,
+                            params: [mockUserOperation],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                    });
+                    expect(result).toEqual(undefined);
+                    expect(mockConsoleWarn).toHaveBeenCalledWith("[PortalProvider] Request for signing method 'eth_signUserOperation' could not be completed because it was not approved by the user.");
+                }));
+            });
             describe('eth_sign', () => {
                 it('should successfully handle an approved eth_sign request', () => __awaiter(void 0, void 0, void 0, function* () {
                     provider.on('portal_signingRequested', () => {

package/lib/esm/index.js

@@ -287,6 +287,9 @@ class Portal {
             yield this.storedClientBackupShare(true, BackupMethods.passkey);
         });
     }
+    configureFirebaseStorage(options) {
+        this.mpc.configureFirebaseStorage(options);
+    }
     backupWallet(backupMethod, progress = () => {
         // Noop
     }, backupConfigs = {}) {
@@ -1111,6 +1114,7 @@ export var BackupMethods;
     BackupMethods["password"] = "PASSWORD";
     BackupMethods["passkey"] = "PASSKEY";
     BackupMethods["custom"] = "CUSTOM";
+    BackupMethods["firebase"] = "FIREBASE";
     BackupMethods["unknown"] = "UNKNOWN";
 })(BackupMethods || (BackupMethods = {}));
 export var GetTransactionsOrder;

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,