@portal-hq/web 3.14.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/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';
+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

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/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';
+const WEB_SDK_VERSION = '3.15.0-alpha.2';
 class Mpc {
     get ready() {
         return this._ready;
@@ -22,6 +22,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,
@@ -51,6 +92,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

package/lib/esm/mpc/index.test.js

@@ -25,6 +25,53 @@ describe('Mpc', () => {
             portal: portalMock,
         });
     });
+    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: BackupMethods.password,
@@ -262,7 +309,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/esm/provider/index.js

@@ -55,6 +55,7 @@ export 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";
@@ -141,6 +142,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,
@@ -444,6 +446,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/esm/provider/index.test.js

@@ -201,6 +201,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: 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: 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: RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                    });
+                    expect(result).toEqual(mockSignedHash);
+                    expect(portal.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: RequestMethod.eth_signUserOperation,
+                        params: mockUserOperation,
+                        rpcUrl: mockRpcUrl,
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'eip155:1',
+                        method: 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({
@@ -669,6 +716,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: RequestMethod.eth_signUserOperation,
+                            params: [mockUserOperation],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                    });
+                    expect(result).toEqual(mockSignedHash);
+                    expect(portal.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: RequestMethod.eth_signUserOperation,
+                        params: mockUserOperation,
+                        rpcUrl: mockRpcUrl,
+                        signatureApprovalMemo: 'Test eth_signUserOperation',
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'eip155:1',
+                        method: 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: RequestMethod.eth_signUserOperation,
+                            params: [mockUserOperation],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'eip155:1',
+                        method: RequestMethod.eth_signUserOperation,
+                        params: [mockUserOperation],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: 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/package.json

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

package/src/index.ts

@@ -48,6 +48,7 @@ import {
   type BackupShareResult,
   type PasskeyOptions,
   type PortalOptions,
+  type FirebaseStorageConfigOptions,
 } from '../types'
 import Mpc from './mpc'
 import Provider, { RequestMethod } from './provider'
@@ -434,6 +435,12 @@ class Portal {
     await this.storedClientBackupShare(true, BackupMethods.passkey)
   }
 
+  public configureFirebaseStorage(
+    options: FirebaseStorageConfigOptions,
+  ): void {
+    this.mpc.configureFirebaseStorage(options)
+  }
+
   public async backupWallet(
     backupMethod: BackupMethods,
     progress: ProgressCallback = () => {
@@ -1568,6 +1575,7 @@ export { PortalMpcError } from './mpc/errors'
 export {
   type Address,
   type Dapp,
+  type FirebaseStorageConfigOptions,
   type ILogger,
   type LogLevel,
   type MpcStatus,
@@ -1592,6 +1600,7 @@ export enum BackupMethods {
   password = 'PASSWORD',
   passkey = 'PASSKEY',
   custom = 'CUSTOM',
+  firebase = 'FIREBASE',
   unknown = 'UNKNOWN',
 }
 

package/src/mpc/index.test.ts

@@ -99,6 +99,75 @@ describe('Mpc', () => {
     })
   })
 
+  describe('configureFirebaseStorage', () => {
+    it('posts configure to iframe and bridges token requests from iframe', async () => {
+      const postSpy = jest
+        .spyOn(mpc.iframe!.contentWindow!, 'postMessage')
+        .mockImplementation(() => {})
+
+      mpc.configureFirebaseStorage({
+        getToken: async (opts) =>
+          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 as unknown as { boundFirebaseTokenBridge: (e: MessageEvent) => void })
+        .boundFirebaseTokenBridge
+      bridge(
+        new MessageEvent('message', {
+          origin: mockHostOrigin,
+          source: mpc.iframe!.contentWindow!,
+          data: {
+            type: 'portal:firebase:requestToken',
+            data: { requestId: 'r1' },
+          },
+        }),
+      )
+      await new Promise<void>((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 },
+          },
+        }),
+      )
+      await new Promise<void>((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: BackupMethods.password,
@@ -371,7 +440,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',
+            'Invalid backup method: INVALID_METHOD. Valid methods are: GDRIVE, PASSWORD, PASSKEY, CUSTOM, FIREBASE, UNKNOWN',
           )
           done()
         })

package/src/mpc/index.ts

@@ -134,7 +134,7 @@ import {
 } from '../../hypernative'
 import { generateTraceId } from '../shared/trace'
 
-const WEB_SDK_VERSION = '3.14.0'
+const WEB_SDK_VERSION = '3.15.0-alpha.2'
 
 class Mpc {
   public iframe?: HTMLIFrameElement
@@ -142,6 +142,52 @@ class Mpc {
   private portal: Portal
   private _ready = false
   private presignatureLogHandler: ((event: MessageEvent) => void) | null = null
+  private firebaseGetToken?: (
+    options?: { forceRefresh?: boolean },
+  ) => Promise<string | null>
+
+  private boundFirebaseTokenBridge = (event: MessageEvent) => {
+    const { origin } = event
+    if (origin !== this.getOrigin()) {
+      return
+    }
+    if (event.source !== this.iframe?.contentWindow) {
+      return
+    }
+    const { type, data } = event.data || {}
+    if (type !== 'portal:firebase:requestToken') {
+      return
+    }
+    const requestId = data?.requestId as string | undefined
+    if (!requestId) {
+      return
+    }
+    const getter = this.firebaseGetToken
+    void (async () => {
+      try {
+        if (!getter) {
+          throw new Error(
+            'Firebase storage is not configured (getToken missing)',
+          )
+        }
+        const token = await getter({
+          forceRefresh: 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 },
+        })
+      }
+    })()
+  }
 
   public get ready() {
     return this._ready
@@ -159,6 +205,18 @@ class Mpc {
 
     // Create the iFrame for MPC operations
     this.appendIframe()
+    window.addEventListener('message', this.boundFirebaseTokenBridge)
+  }
+
+  public configureFirebaseStorage(options: {
+    getToken: (options?: { forceRefresh?: boolean }) => Promise<string | null>
+    tbsHost?: string
+  }): void {
+    this.firebaseGetToken = options.getToken
+    this.postMessage({
+      type: 'portal:firebase:configure',
+      data: { tbsHost: options.tbsHost },
+    })
   }
 
   /*******************************

package/src/provider/index.test.ts

@@ -298,6 +298,73 @@ 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', async () => {
+          expect(
+            provider.request({
+              method: 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', async () => {
+          const chainId = 'unsupported:chain'
+          expect(
+            provider.request({
+              chainId,
+              method: 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', async () => {
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signUserOperation,
+            params: [mockUserOperation],
+            signatureApprovalMemo: 'Test eth_signUserOperation',
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signUserOperation,
+            params: mockUserOperation,
+            rpcUrl: mockRpcUrl,
+            signatureApprovalMemo: 'Test eth_signUserOperation',
+            traceId: 'mock-trace-id-12345',
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'eip155:1',
+              method: RequestMethod.eth_signUserOperation,
+              params: [mockUserOperation],
+              signature: result,
+            },
+          )
+        })
+      })
+
       describe('eth_sign', () => {
         it('should throw an error if no chainId is provided alongside eth_sign', async () => {
           expect(
@@ -939,6 +1006,76 @@ describe('Provider', () => {
         })
       })
 
+      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', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.eth_signUserOperation,
+              params: [mockUserOperation],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signUserOperation,
+            params: [mockUserOperation],
+            signatureApprovalMemo: 'Test eth_signUserOperation',
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.eth_signUserOperation,
+            params: [mockUserOperation],
+            signatureApprovalMemo: 'Test eth_signUserOperation',
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signUserOperation,
+            params: mockUserOperation,
+            rpcUrl: mockRpcUrl,
+            signatureApprovalMemo: 'Test eth_signUserOperation',
+            traceId: 'mock-trace-id-12345',
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signUserOperation,
+            params: [mockUserOperation],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected eth_signUserOperation request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.eth_signUserOperation,
+              params: [mockUserOperation],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'eip155:1',
+            method: RequestMethod.eth_signUserOperation,
+            params: [mockUserOperation],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: 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', async () => {
           provider.on('portal_signingRequested', () => {

package/src/provider/index.ts

@@ -56,6 +56,7 @@ export enum RequestMethod {
   eth_sendTransaction = 'eth_sendTransaction',
   eth_sign = 'eth_sign',
   eth_signTransaction = 'eth_signTransaction',
+  eth_signUserOperation = 'eth_signUserOperation',
   eth_signTypedData = 'eth_signTypedData',
   eth_signTypedData_v3 = 'eth_signTypedData_v3',
   eth_signTypedData_v4 = 'eth_signTypedData_v4',
@@ -148,6 +149,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,
@@ -502,6 +504,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/src/shared/types/common.ts

@@ -701,7 +701,13 @@ export interface CustomBackupConfig {
 }
 
 // Backup method types - matches enum values from both browser and iframe packages
-export type BackupMethod = 'GDRIVE' | 'PASSWORD' | 'PASSKEY' | 'CUSTOM' | 'UNKNOWN'
+export type BackupMethod =
+  | 'GDRIVE'
+  | 'PASSWORD'
+  | 'PASSKEY'
+  | 'CUSTOM'
+  | 'FIREBASE'
+  | 'UNKNOWN'
 
 export interface BackupConfigs {
   passwordStorage?: PasswordConfig

package/types.d.ts

@@ -115,6 +115,11 @@ export type MessageData =
 export type ProgressCallback = (status: MpcStatus) => void | Promise<void>
 export type ValidRpcErrorCodes = 4001 | 4100 | 4200 | 4900 | 4901
 
+export interface FirebaseStorageConfigOptions {
+  getToken: (options?: { forceRefresh?: boolean }) => Promise<string | null>
+  tbsHost?: string
+}
+
 // Interfaces
 
 export interface BackupArgs extends MpcOperationArgs {