@portal-hq/web 3.6.2-alpha → 3.7.0

package/lib/esm/index.test.js

@@ -116,6 +116,123 @@ describe('Portal', () => {
             }, mockProgressFn);
         }));
     });
+    describe('generateBackupShare', () => {
+        it('should request a custom backup and return cipherText and encryptionKey', () => __awaiter(void 0, void 0, void 0, function* () {
+            const storageCallback = jest.fn().mockResolvedValue(undefined);
+            portal.mpc.backup.mockResolvedValueOnce({
+                cipherText: mockCipherText,
+                encryptionKey: 'manual-key',
+                storageCallback,
+            });
+            const result = yield portal.generateBackupShare();
+            expect(result).toEqual({
+                cipherText: mockCipherText,
+                encryptionKey: 'manual-key',
+            });
+            expect(portal.mpc.backup).toHaveBeenCalledWith({
+                backupMethod: BackupMethods.custom,
+                backupConfigs: {},
+                host: 'web.portalhq.io',
+                mpcVersion: 'v6',
+                featureFlags: {},
+            }, expect.any(Function));
+        }));
+        it('should throw if the iframe response does not contain an encryption key', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.backup.mockResolvedValueOnce({
+                cipherText: mockCipherText,
+                storageCallback: jest.fn(),
+            });
+            yield expect(portal.generateBackupShare()).rejects.toThrow('Custom backup did not return an encryption key');
+        }));
+    });
+    describe('registerPasskeyAndStoreEncryptionKey', () => {
+        it('should delegate to the passkey service with computed relying party data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const passkeyServiceMock = {
+                registerPasskeyAndStoreKey: jest.fn().mockResolvedValue(undefined),
+            };
+            portal.passkeyService = passkeyServiceMock;
+            portal.passkeyServiceDefaultDomain = 'backup.web.portalhq.io';
+            portal.passkeyServiceApiKey = portal.apiKey;
+            yield portal.registerPasskeyAndStoreEncryptionKey(mockCipherText, 'manual-key');
+            expect(passkeyServiceMock.registerPasskeyAndStoreKey).toHaveBeenCalledTimes(1);
+            expect(passkeyServiceMock.registerPasskeyAndStoreKey).toHaveBeenCalledWith(expect.objectContaining({
+                customDomain: undefined,
+                encryptionKey: 'manual-key',
+                relyingPartyId: 'backup.web.portalhq.io',
+                relyingPartyName: 'Portal',
+                cipherText: mockCipherText,
+            }));
+        }));
+        it('should throw when usePopup is requested', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.registerPasskeyAndStoreEncryptionKey(mockCipherText, 'manual-key', { usePopup: true })).rejects.toThrow('does not support the popup flow');
+        }));
+    });
+    describe('authenticatePasskeyAndRetrieveKey', () => {
+        it('should invoke the passkey service for direct authentication', () => __awaiter(void 0, void 0, void 0, function* () {
+            const passkeyServiceMock = {
+                authenticatePasskeyAndRetrieveKey: jest
+                    .fn()
+                    .mockResolvedValue('retrieved-key'),
+            };
+            portal.passkeyService = passkeyServiceMock;
+            portal.passkeyServiceDefaultDomain = 'backup.web.portalhq.io';
+            portal.passkeyServiceApiKey = portal.apiKey;
+            const key = yield portal.authenticatePasskeyAndRetrieveKey();
+            expect(key).toEqual('retrieved-key');
+            expect(passkeyServiceMock.authenticatePasskeyAndRetrieveKey).toHaveBeenCalledWith(expect.objectContaining({
+                customDomain: undefined,
+                relyingPartyId: 'backup.web.portalhq.io',
+                relyingPartyName: 'Portal',
+            }));
+        }));
+        it('should throw when usePopup is true', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(portal.authenticatePasskeyAndRetrieveKey({ usePopup: true })).rejects.toThrow('does not support the popup flow');
+        }));
+    });
+    describe('backupWithPasskey', () => {
+        it('should orchestrate the direct passkey flow when usePopup is false', () => __awaiter(void 0, void 0, void 0, function* () {
+            const directShare = {
+                cipherText: mockCipherText,
+                encryptionKey: 'manual-key',
+            };
+            const generateSpy = jest
+                .spyOn(portal, 'generateBackupShare')
+                .mockResolvedValue(directShare);
+            const registerSpy = jest
+                .spyOn(portal, 'registerPasskeyAndStoreEncryptionKey')
+                .mockResolvedValue(undefined);
+            const storedClientBackupShareSpy = jest
+                .spyOn(portal, 'storedClientBackupShare')
+                .mockResolvedValue(undefined);
+            yield portal.backupWithPasskey({
+                usePopup: false,
+                customDomain: 'passkeys.wigwam.app',
+                relyingPartyName: 'Wigwam',
+            }, undefined);
+            expect(generateSpy).toHaveBeenCalledTimes(1);
+            expect(registerSpy).toHaveBeenCalledWith(directShare.cipherText, directShare.encryptionKey, expect.objectContaining({
+                customDomain: 'passkeys.wigwam.app',
+                relyingPartyName: 'Wigwam',
+                usePopup: false,
+            }));
+            expect(storedClientBackupShareSpy).toHaveBeenCalledWith(true, BackupMethods.passkey);
+            generateSpy.mockRestore();
+            registerSpy.mockRestore();
+            storedClientBackupShareSpy.mockRestore();
+        }));
+        it('should fall back to the legacy popup flow when usePopup is true', () => __awaiter(void 0, void 0, void 0, function* () {
+            const progress = jest.fn();
+            yield portal.backupWithPasskey({}, progress);
+            expect(portal.mpc.backup).toHaveBeenCalledWith({
+                backupMethod: BackupMethods.passkey,
+                backupConfigs: {},
+                host: 'web.portalhq.io',
+                mpcVersion: 'v6',
+                featureFlags: {},
+            }, progress);
+        }));
+    });
     describe('recoverWallet', () => {
         it('should successfully recover a wallet and call mpc.recover correctly', () => __awaiter(void 0, void 0, void 0, function* () {
             const mockProgressFn = jest.fn();
@@ -537,14 +654,14 @@ describe('Portal', () => {
         it('should correctly call mpc.getQuote', () => __awaiter(void 0, void 0, void 0, function* () {
             yield portal.getQuote('test', mockQuoteArgs, 'eip155:1');
             expect(portal.mpc.getQuote).toHaveBeenCalledTimes(1);
-            expect(portal.mpc.getQuote).toHaveBeenCalledWith('test', mockQuoteArgs, 'eip155:1');
+            expect(portal.mpc.getQuote).toHaveBeenCalledWith('eip155:1', mockQuoteArgs, 'test');
         }));
     });
     describe('getSources', () => {
         it('should correctly call mpc.getSources', () => __awaiter(void 0, void 0, void 0, function* () {
             yield portal.getSources('test', 'eip155:1');
             expect(portal.mpc.getSources).toHaveBeenCalledTimes(1);
-            expect(portal.mpc.getSources).toHaveBeenCalledWith('test', 'eip155:1');
+            expect(portal.mpc.getSources).toHaveBeenCalledWith('eip155:1', 'test');
         }));
     });
     describe('storedClientBackupShare', () => {

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

@@ -0,0 +1,98 @@
+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());
+    });
+};
+export default 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);
+        });
+    }
+}

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

@@ -0,0 +1,146 @@
+/**
+ * @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;
+};
+import Hypernative from '.';
+import Mpc from '../../../mpc';
+import portalMock from '../../../__mocks/portal/portal';
+import { mockHost, mockScanAddressesRequest, mockScanAddressesResponse, mockScanEVMTxRequest, mockScanEVMTxResponse, mockScanEip712TxRequest, mockScanEip712TxResponse, mockScanSolanaTxRequest, mockScanSolanaTxResponse, mockScanNftRequest, mockScanNftResponse, mockScanTokenRequest, mockScanTokenResponse, mockScanUrlRequest, mockScanUrlResponse, } from '../../../__mocks/constants';
+describe('Hypernative', () => {
+    let hypernative;
+    let mpc;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        portalMock.host = mockHost;
+        mpc = new Mpc({
+            portal: portalMock,
+        });
+        hypernative = new Hypernative({ 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(mockScanEVMTxResponse);
+            const result = yield hypernative.scanEVMTx(mockScanEVMTxRequest);
+            expect(spy).toHaveBeenCalledWith(mockScanEVMTxRequest);
+            expect(result).toEqual(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(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(mockScanEip712TxResponse);
+            const result = yield hypernative.scanEip712Tx(mockScanEip712TxRequest);
+            expect(spy).toHaveBeenCalledWith(mockScanEip712TxRequest);
+            expect(result).toEqual(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(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(mockScanSolanaTxResponse);
+            const result = yield hypernative.scanSolanaTx(mockScanSolanaTxRequest);
+            expect(spy).toHaveBeenCalledWith(mockScanSolanaTxRequest);
+            expect(result).toEqual(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(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(mockScanAddressesResponse);
+            const { addresses } = mockScanAddressesRequest, options = __rest(mockScanAddressesRequest, ["addresses"]);
+            const result = yield hypernative.scanAddresses(addresses, options);
+            expect(spy).toHaveBeenCalledWith(mockScanAddressesRequest);
+            expect(result).toEqual(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 } = mockScanAddressesRequest, options = __rest(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(mockScanNftResponse);
+            const result = yield hypernative.scanNFTs(mockScanNftRequest);
+            expect(spy).toHaveBeenCalledWith(mockScanNftRequest);
+            expect(result).toEqual(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(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(mockScanTokenResponse);
+            const result = yield hypernative.scanTokens(mockScanTokenRequest);
+            expect(spy).toHaveBeenCalledWith(mockScanTokenRequest);
+            expect(result).toEqual(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(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(mockScanUrlResponse);
+            const result = yield hypernative.scanURL(mockScanUrlRequest);
+            expect(spy).toHaveBeenCalledWith(mockScanUrlRequest);
+            expect(result).toEqual(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(mockScanUrlRequest)).rejects.toThrow('Test error');
+        }));
+    });
+});

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

@@ -0,0 +1,10 @@
+import Hypernative from './hypernative';
+/**
+ * This class is a container for the Hypernative class.
+ * In the future, Security domain logic should be here.
+ */
+export default class Security {
+    constructor({ mpc }) {
+        this.hypernative = new Hypernative({ mpc });
+    }
+}

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

@@ -19,10 +19,10 @@ export default 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);
         });
     }
     /**
@@ -32,10 +32,23 @@ export default 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/esm/integrations/trading/zero-x/index.test.js

@@ -13,7 +13,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import ZeroX from '.';
 import Mpc from '../../../mpc';
 import portalMock from '../../../__mocks/portal/portal';
-import { mockHost, mockQuoteArgs, mockSourcesRes, mockZeroXQuoteResponse, } from '../../../__mocks/constants';
+import { mockHost, mockSourcesRes, mockZeroExQuoteV2Request, mockZeroExQuoteV2Response, mockZeroExOptions, mockZeroExPriceRequest, mockZeroExPriceResponse, } from '../../../__mocks/constants';
 describe('ZeroX', () => {
     let zeroX;
     let mpc;
@@ -26,35 +26,81 @@ describe('ZeroX', () => {
         zeroX = new ZeroX({ 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(mockZeroXQuoteResponse);
-            const result = yield zeroX.getQuote('test', mockQuoteArgs, 'eip155:1');
+                .spyOn(mpc, 'getSwapsQuoteV2')
+                .mockResolvedValue(mockZeroExQuoteV2Response);
+            const result = yield zeroX.getQuote(mockZeroExQuoteV2Request, mockZeroExOptions);
             expect(spy).toHaveBeenCalledTimes(1);
-            expect(spy).toHaveBeenCalledWith('test', mockQuoteArgs, 'eip155:1');
-            expect(result).toEqual(mockZeroXQuoteResponse);
+            expect(spy).toHaveBeenCalledWith(mockZeroExQuoteV2Request, mockZeroExOptions);
+            expect(result).toEqual(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(mockZeroExQuoteV2Response);
+            const result = yield zeroX.getQuote(mockZeroExQuoteV2Request);
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith(mockZeroExQuoteV2Request, undefined);
+            expect(result).toEqual(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', mockQuoteArgs, 'eip155:1')).rejects.toThrow('Test error');
+            jest.spyOn(mpc, 'getSwapsQuoteV2').mockRejectedValue(error);
+            yield expect(zeroX.getQuote(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(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(mockSourcesRes);
+        }));
+        it('should correctly call mpc.getSources without apiKey', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getSwapsSourcesV2')
+                .mockResolvedValue(mockSourcesRes);
+            const result = yield zeroX.getSources('eip155:1');
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith({ chainId: 'eip155:1' }, undefined);
             expect(result).toEqual(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(mockZeroExPriceResponse);
+            const result = yield zeroX.getPrice(mockZeroExPriceRequest, mockZeroExOptions);
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith(mockZeroExPriceRequest, mockZeroExOptions);
+            expect(result).toEqual(mockZeroExPriceResponse);
+        }));
+        it('should correctly call mpc.getSwapsPrice without options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const spy = jest
+                .spyOn(mpc, 'getSwapsPrice')
+                .mockResolvedValue(mockZeroExPriceResponse);
+            const result = yield zeroX.getPrice(mockZeroExPriceRequest);
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith(mockZeroExPriceRequest, undefined);
+            expect(result).toEqual(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(mockZeroExPriceRequest)).rejects.toThrow('Test error');
         }));
     });
 });