@portal-hq/web 3.6.2-alpha → 3.7.0

package/lib/commonjs/integrations/security/hypernative/index.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class Hypernative {
+    constructor({ mpc }) {
+        this.mpc = mpc;
+    }
+    /**
+     * Scans an EIP-155 transaction for security risks.
+     * @param data - The parameters for the EIP-155 transaction scan request.
+     * @returns A `ScanEVMResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanEVMTx(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.scanEVMTx(data);
+        });
+    }
+    /**
+     * Scans an EIP-712 typed message for security risks.
+     * @param data - The parameters for the EIP-712 message scan request.
+     * @returns A `ScanEip712Response` promise.
+     * @throws An error if the operation fails.
+     */
+    scanEip712Tx(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.scanEip712Tx(data);
+        });
+    }
+    /**
+     * Scans a Solana transaction for security risks.
+     * @param data - The parameters for the Solana transaction scan request.
+     * @returns A `ScanSolanaResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanSolanaTx(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.scanSolanaTx(data);
+        });
+    }
+    /**
+     * Scans addresses for security risks and flags.
+     * @param data - The parameters for the address scan request.
+     * @returns A `ScreenAddressApiResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanAddresses(addresses, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.scanAddresses(Object.assign({ addresses }, options));
+        });
+    }
+    /**
+     * Scans NFTs for security risks.
+     * @param data - The parameters for the NFT scan request.
+     * @returns A `ScanNftResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanNFTs(nfts) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.scanNFTs(nfts);
+        });
+    }
+    /**
+     * Scans tokens for security risks.
+     * @param data - The parameters for the token scan request.
+     * @returns A `ScanTokenResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanTokens(tokens) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.scanTokens(tokens);
+        });
+    }
+    /**
+     * Scans a URL for malicious content.
+     * @param data - The parameters for the URL scan request.
+     * @returns A `ScanUrlResponse` promise.
+     * @throws An error if the operation fails.
+     */
+    scanURL(url) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.scanUrl(url);
+        });
+    }
+}
+exports.default = Hypernative;

package/lib/commonjs/integrations/security/hypernative/index.test.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * @jest-environment jsdom
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = __importDefault(require("."));
+const mpc_1 = __importDefault(require("../../../mpc"));
+const portal_1 = __importDefault(require("../../../__mocks/portal/portal"));
+const constants_1 = require("../../../__mocks/constants");
+describe('Hypernative', () => {
+    let hypernative;
+    let mpc;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portal_1.default.host = constants_1.mockHost;
+        mpc = new mpc_1.default({
+            portal: portal_1.default,
+        });
+        hypernative = new _1.default({ mpc });
+    });
+    describe('scanEVMTx', () => {
+        it('should call mpc.scanEVMTx with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'scanEVMTx')
+                .mockResolvedValue(constants_1.mockScanEVMTxResponse);
+            const result = yield hypernative.scanEVMTx(constants_1.mockScanEVMTxRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockScanEVMTxRequest);
+            expect(result).toEqual(constants_1.mockScanEVMTxResponse);
+        }));
+        it('should propagate errors from mpc.scanEVMTx', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'scanEVMTx').mockRejectedValue(error);
+            yield expect(hypernative.scanEVMTx(constants_1.mockScanEVMTxRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanEip712Tx', () => {
+        it('should call mpc.scanEip712Tx with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'scanEip712Tx')
+                .mockResolvedValue(constants_1.mockScanEip712TxResponse);
+            const result = yield hypernative.scanEip712Tx(constants_1.mockScanEip712TxRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockScanEip712TxRequest);
+            expect(result).toEqual(constants_1.mockScanEip712TxResponse);
+        }));
+        it('should propagate errors from mpc.scanEip712Tx', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'scanEip712Tx').mockRejectedValue(error);
+            yield expect(hypernative.scanEip712Tx(constants_1.mockScanEip712TxRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanSolanaTx', () => {
+        it('should call mpc.scanSolanaTx with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'scanSolanaTx')
+                .mockResolvedValue(constants_1.mockScanSolanaTxResponse);
+            const result = yield hypernative.scanSolanaTx(constants_1.mockScanSolanaTxRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockScanSolanaTxRequest);
+            expect(result).toEqual(constants_1.mockScanSolanaTxResponse);
+        }));
+        it('should propagate errors from mpc.scanSolanaTx', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'scanSolanaTx').mockRejectedValue(error);
+            yield expect(hypernative.scanSolanaTx(constants_1.mockScanSolanaTxRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanAddresses', () => {
+        it('should call mpc.scanAddresses with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'scanAddresses')
+                .mockResolvedValue(constants_1.mockScanAddressesResponse);
+            const { addresses } = constants_1.mockScanAddressesRequest, options = __rest(constants_1.mockScanAddressesRequest, ["addresses"]);
+            const result = yield hypernative.scanAddresses(addresses, options);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockScanAddressesRequest);
+            expect(result).toEqual(constants_1.mockScanAddressesResponse);
+        }));
+        it('should propagate errors from mpc.scanAddresses', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'scanAddresses').mockRejectedValue(error);
+            const { addresses } = constants_1.mockScanAddressesRequest, options = __rest(constants_1.mockScanAddressesRequest, ["addresses"]);
+            yield expect(hypernative.scanAddresses(addresses, options)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanNFTs', () => {
+        it('should call mpc.scanNFTs with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'scanNFTs')
+                .mockResolvedValue(constants_1.mockScanNftResponse);
+            const result = yield hypernative.scanNFTs(constants_1.mockScanNftRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockScanNftRequest);
+            expect(result).toEqual(constants_1.mockScanNftResponse);
+        }));
+        it('should propagate errors from mpc.scanNFTs', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'scanNFTs').mockRejectedValue(error);
+            yield expect(hypernative.scanNFTs(constants_1.mockScanNftRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanTokens', () => {
+        it('should call mpc.scanTokens with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'scanTokens')
+                .mockResolvedValue(constants_1.mockScanTokenResponse);
+            const result = yield hypernative.scanTokens(constants_1.mockScanTokenRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockScanTokenRequest);
+            expect(result).toEqual(constants_1.mockScanTokenResponse);
+        }));
+        it('should propagate errors from mpc.scanTokens', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'scanTokens').mockRejectedValue(error);
+            yield expect(hypernative.scanTokens(constants_1.mockScanTokenRequest)).rejects.toThrow('Test error');
+        }));
+    });
+    describe('scanURL', () => {
+        it('should call mpc.scanUrl with the correct arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'scanUrl')
+                .mockResolvedValue(constants_1.mockScanUrlResponse);
+            const result = yield hypernative.scanURL(constants_1.mockScanUrlRequest);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockScanUrlRequest);
+            expect(result).toEqual(constants_1.mockScanUrlResponse);
+        }));
+        it('should propagate errors from mpc.scanUrl', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'scanUrl').mockRejectedValue(error);
+            yield expect(hypernative.scanURL(constants_1.mockScanUrlRequest)).rejects.toThrow('Test error');
+        }));
+    });
+});

package/lib/commonjs/integrations/security/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hypernative_1 = __importDefault(require("./hypernative"));
+/**
+ * This class is a container for the Hypernative class.
+ * In the future, Security domain logic should be here.
+ */
+class Security {
+    constructor({ mpc }) {
+        this.hypernative = new hypernative_1.default({ mpc });
+    }
+}
+exports.default = Security;

package/lib/commonjs/integrations/trading/zero-x/index.js

@@ -21,10 +21,10 @@ class ZeroX {
      * @param chainId - The chain ID for the quote.
      * @returns The quote response.
      */
-    getQuote(apiKey, args, chainId) {
+    getQuote(args, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getQuote(apiKey, args, chainId);
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getSwapsQuoteV2(args, options);
         });
     }
     /**
@@ -34,10 +34,23 @@ class ZeroX {
      * @param chainId - The chain ID for the sources.
      * @returns The sources response.
      */
-    getSources(apiKey, chainId) {
+    getSources(chainId, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getSources(apiKey, chainId);
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getSwapsSourcesV2({ chainId }, options);
+        });
+    }
+    /**
+     * Get the price of a token from the Swaps API.
+     *
+     * @param args - The arguments for the price.
+     * @param options - The options for the price.
+     * @returns The price response.
+     */
+    getPrice(args, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getSwapsPrice(args, options);
         });
     }
 }

package/lib/commonjs/integrations/trading/zero-x/index.test.js

@@ -31,35 +31,81 @@ describe('ZeroX', () => {
         zeroX = new _1.default({ mpc });
     });
     describe('getQuote', () => {
-        it('should correctly call mpc.getQuote', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should correctly call mpc.getSwapsQuoteV2 with args and options', () => __awaiter(void 0, void 0, void 0, function* () {
             const spy = jest
-                .spyOn(mpc, 'getQuote')
-                .mockResolvedValue(constants_1.mockZeroXQuoteResponse);
-            const result = yield zeroX.getQuote('test', constants_1.mockQuoteArgs, 'eip155:1');
+                .spyOn(mpc, 'getSwapsQuoteV2')
+                .mockResolvedValue(constants_1.mockZeroExQuoteV2Response);
+            const result = yield zeroX.getQuote(constants_1.mockZeroExQuoteV2Request, constants_1.mockZeroExOptions);
             expect(spy).toHaveBeenCalledTimes(1);
-            expect(spy).toHaveBeenCalledWith('test', constants_1.mockQuoteArgs, 'eip155:1');
-            expect(result).toEqual(constants_1.mockZeroXQuoteResponse);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockZeroExQuoteV2Request, constants_1.mockZeroExOptions);
+            expect(result).toEqual(constants_1.mockZeroExQuoteV2Response);
         }));
-        it('should propagate errors from mpc.getQuote', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should correctly call mpc.getSwapsQuoteV2 without options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getSwapsQuoteV2')
+                .mockResolvedValue(constants_1.mockZeroExQuoteV2Response);
+            const result = yield zeroX.getQuote(constants_1.mockZeroExQuoteV2Request);
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockZeroExQuoteV2Request, undefined);
+            expect(result).toEqual(constants_1.mockZeroExQuoteV2Response);
+        }));
+        it('should propagate errors from mpc.getSwapsQuoteV2', () => __awaiter(void 0, void 0, void 0, function* () {
             const error = new Error('Test error');
-            jest.spyOn(mpc, 'getQuote').mockRejectedValue(error);
-            yield expect(zeroX.getQuote('test', constants_1.mockQuoteArgs, 'eip155:1')).rejects.toThrow('Test error');
+            jest.spyOn(mpc, 'getSwapsQuoteV2').mockRejectedValue(error);
+            yield expect(zeroX.getQuote(constants_1.mockZeroExQuoteV2Request)).rejects.toThrow('Test error');
         }));
     });
     describe('getSources', () => {
-        it('should correctly call mpc.getSources', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should correctly call mpc.getSources with chainId and apiKey', () => __awaiter(void 0, void 0, void 0, function* () {
             const spy = jest
-                .spyOn(mpc, 'getSources')
+                .spyOn(mpc, 'getSwapsSourcesV2')
                 .mockResolvedValue(constants_1.mockSourcesRes);
-            const result = yield zeroX.getSources('test', 'eip155:1');
+            const result = yield zeroX.getSources('eip155:1', {
+                zeroXApiKey: 'test-api-key',
+            });
+            console.log(`Result:`, result);
             expect(spy).toHaveBeenCalledTimes(1);
-            expect(spy).toHaveBeenCalledWith('test', 'eip155:1');
+            expect(spy).toHaveBeenCalledWith({ chainId: 'eip155:1' }, { zeroXApiKey: 'test-api-key' });
+            expect(result).toEqual(constants_1.mockSourcesRes);
+        }));
+        it('should correctly call mpc.getSources without apiKey', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getSwapsSourcesV2')
+                .mockResolvedValue(constants_1.mockSourcesRes);
+            const result = yield zeroX.getSources('eip155:1');
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith({ chainId: 'eip155:1' }, undefined);
             expect(result).toEqual(constants_1.mockSourcesRes);
         }));
         it('should propagate errors from mpc.getSources', () => __awaiter(void 0, void 0, void 0, function* () {
             const error = new Error('Test error');
-            jest.spyOn(mpc, 'getSources').mockRejectedValue(error);
-            yield expect(zeroX.getSources('test', 'eip155:1')).rejects.toThrow('Test error');
+            jest.spyOn(mpc, 'getSwapsSourcesV2').mockRejectedValue(error);
+            yield expect(zeroX.getSources('eip155:1')).rejects.toThrow('Test error');
+        }));
+    });
+    describe('getPrice', () => {
+        it('should correctly call mpc.getSwapsPrice with args and options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getSwapsPrice')
+                .mockResolvedValue(constants_1.mockZeroExPriceResponse);
+            const result = yield zeroX.getPrice(constants_1.mockZeroExPriceRequest, constants_1.mockZeroExOptions);
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockZeroExPriceRequest, constants_1.mockZeroExOptions);
+            expect(result).toEqual(constants_1.mockZeroExPriceResponse);
+        }));
+        it('should correctly call mpc.getSwapsPrice without options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getSwapsPrice')
+                .mockResolvedValue(constants_1.mockZeroExPriceResponse);
+            const result = yield zeroX.getPrice(constants_1.mockZeroExPriceRequest);
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith(constants_1.mockZeroExPriceRequest, undefined);
+            expect(result).toEqual(constants_1.mockZeroExPriceResponse);
+        }));
+        it('should propagate errors from mpc.getSwapsPrice', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Test error');
+            jest.spyOn(mpc, 'getSwapsPrice').mockRejectedValue(error);
+            yield expect(zeroX.getPrice(constants_1.mockZeroExPriceRequest)).rejects.toThrow('Test error');
         }));
     });
 });

package/lib/commonjs/mpc/index.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MpcErrorCodes = exports.MpcError = void 0;
 const errors_1 = require("./errors");
 const index_1 = require("../index");
-const WEB_SDK_VERSION = '3.6.2-alpha';
+const WEB_SDK_VERSION = '3.7.0';
 class Mpc {
     get ready() {
         return this._ready;
@@ -81,12 +81,19 @@ class Mpc {
                         // Remove the event listeners
                         window.removeEventListener('message', handleBackup);
                         window.removeEventListener('message', handleProgress);
+                        const resultData = result;
+                        const backupIds = Array.isArray(resultData.backupIds)
+                            ? resultData.backupIds
+                            : [];
                         const storageCallback = () => __awaiter(this, void 0, void 0, function* () {
-                            yield this.setBackupStatus('STORED_CLIENT_BACKUP_SHARE', result.backupIds);
+                            yield this.setBackupStatus('STORED_CLIENT_BACKUP_SHARE', backupIds);
                         });
                         // Resolve the promise with the result
                         resolve({
-                            cipherText: result.cipherText,
+                            cipherText: resultData.cipherText,
+                            encryptionKey: typeof resultData.encryptionKey === 'string'
+                                ? resultData.encryptionKey
+                                : undefined,
                             storageCallback,
                         });
                     }
@@ -673,7 +680,7 @@ class Mpc {
             });
         });
     }
-    getQuote(apiKey, args, chainId) {
+    getQuote(chainId, args, apiKey) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
                 const handleGetQuote = (event) => {
@@ -710,7 +717,7 @@ class Mpc {
             });
         });
     }
-    getSources(apiKey, chainId) {
+    getSources(chainId, apiKey) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
                 const handleGetSources = (event) => {
@@ -1112,6 +1119,109 @@ class Mpc {
             });
         });
     }
+    getSwapsQuoteV2(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:swaps:getQuoteV2',
+                errorMessage: 'portal:swaps:getQuoteV2Error',
+                resultMessage: 'portal:swaps:getQuoteV2Result',
+                data: Object.assign(Object.assign({}, data), { options }),
+            });
+        });
+    }
+    getSwapsSourcesV2(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:swaps:getSourcesV2',
+                errorMessage: 'portal:swaps:getSourcesV2Error',
+                resultMessage: 'portal:swaps:getSourcesV2Result',
+                data: Object.assign(Object.assign({}, data), { options }),
+            });
+        });
+    }
+    getSwapsPrice(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:swaps:getPrice',
+                errorMessage: 'portal:swaps:getPriceError',
+                resultMessage: 'portal:swaps:getPriceResult',
+                data: Object.assign(Object.assign({}, data), { options }),
+            });
+        });
+    }
+    /*******************************
+     * Security Methods
+     *******************************/
+    scanAddresses(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:security:scanAddresses',
+                errorMessage: 'portal:security:scanAddressesError',
+                resultMessage: 'portal:security:scanAddressesResult',
+                data,
+            });
+        });
+    }
+    scanEVMTx(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:security:scanEVMTx',
+                errorMessage: 'portal:security:scanEVMTxError',
+                resultMessage: 'portal:security:scanEVMTxResult',
+                data,
+            });
+        });
+    }
+    scanEip712Tx(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:security:scanEip712Tx',
+                errorMessage: 'portal:security:scanEip712TxError',
+                resultMessage: 'portal:security:scanEip712TxResult',
+                data,
+            });
+        });
+    }
+    scanSolanaTx(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:security:scanSolanaTx',
+                errorMessage: 'portal:security:scanSolanaTxError',
+                resultMessage: 'portal:security:scanSolanaTxResult',
+                data,
+            });
+        });
+    }
+    scanNFTs(nfts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:security:scanNfts',
+                errorMessage: 'portal:security:scanNftsError',
+                resultMessage: 'portal:security:scanNftsResult',
+                data: nfts,
+            });
+        });
+    }
+    scanTokens(tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:security:scanTokens',
+                errorMessage: 'portal:security:scanTokensError',
+                resultMessage: 'portal:security:scanTokensResult',
+                data: tokens,
+            });
+        });
+    }
+    scanUrl(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.handleRequestToIframeAndPost({
+                methodMessage: 'portal:security:scanUrl',
+                errorMessage: 'portal:security:scanUrlError',
+                resultMessage: 'portal:security:scanUrlResult',
+                data: { url },
+            });
+        });
+    }
     /***************************
      * Private Methods
      ***************************/
@@ -1175,6 +1285,47 @@ class Mpc {
             : `https://${host}`;
         return origin;
     }
+    /**
+     * Fetches a scoped JWT for passkey operations from the iframe.
+     * The JWT has only "passkey" permission, reducing blast radius if compromised.
+     */
+    getPasskeyJwt() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const handleResult = (event) => {
+                    const { type, data } = event.data;
+                    const { origin } = event;
+                    // ignore any broadcast postMessages
+                    if (origin !== this.getOrigin()) {
+                        return;
+                    }
+                    if (type === 'portal:getPasskeyJwtResult') {
+                        window.removeEventListener('message', handleResult);
+                        window.removeEventListener('message', handleError);
+                        resolve(data.token);
+                    }
+                };
+                const handleError = (event) => {
+                    const { type, data } = event.data;
+                    const { origin } = event;
+                    if (origin !== this.getOrigin()) {
+                        return;
+                    }
+                    if (type === 'portal:getPasskeyJwtError') {
+                        window.removeEventListener('message', handleResult);
+                        window.removeEventListener('message', handleError);
+                        reject(new Error(data.message));
+                    }
+                };
+                window.addEventListener('message', handleResult);
+                window.addEventListener('message', handleError);
+                this.postMessage({
+                    type: 'portal:getPasskeyJwt',
+                    data: {},
+                });
+            });
+        });
+    }
     postMessage(event) {
         var _a, _b;
         (_b = (_a = this.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow) === null || _b === void 0 ? void 0 : _b.postMessage(event, this.getOrigin());