@portal-hq/web 3.17.0 → 3.18.0-alpha.0

package/lib/esm/index.js

@@ -19,6 +19,7 @@ import PasskeyService from './passkeys';
 import { EvmAccountType } from './namespaces/evmAccountType';
 import { sdkLogger } from './logger';
 import { generateTraceId } from './shared/trace';
+import { buildDefaultRpcConfig, DEFAULT_RPC_HOST } from './shared/rpc/defaults';
 import { waitForEvmOrUserOpConfirmation } from './internal/waitForEvmOrUserOpConfirmation';
 import { waitForSolanaTxConfirmation } from './internal/waitForSolanaTxConfirmation';
 class Portal {
@@ -32,12 +33,14 @@ class Portal {
         return this._iframeRpcConfig;
     }
     constructor({ 
-    // Required
-    rpcConfig, 
+    // Optional — defaults to Portal-managed RPC gateway when omitted or empty
+    rpcConfig, gatewayHost, 
     // Optional
-    iframeRpcConfig, apiKey, authToken, authUrl, autoApprove = false, gdrive, passkey, host = 'web.portalhq.io', mpcVersion = 'v6', mpcHost = 'mpc-client.portalhq.io', featureFlags = {}, chainId, logLevel = 'none', logger = console, }) {
+    iframeRpcConfig, apiKey, authToken, authUrl, autoApprove = false, gdrive, passkey, host = DEFAULT_RPC_HOST, mpcVersion = 'v6', mpcHost = 'mpc-client.portalhq.io', featureFlags = {}, chainId, logLevel = 'none', logger = console, }) {
         this.errorCallbacks = [];
         this.readyCallbacks = [];
+        this.walletNotOnDeviceCallbacks = [];
+        this.lastWalletNotOnDevicePayload = null;
         this.logger = console;
         this.sendEth = ({ chainId, to, value, }) => __awaiter(this, void 0, void 0, function* () {
             return this.provider.request({
@@ -52,11 +55,27 @@ class Portal {
                 ],
             });
         });
+        // Gateway host resolution — three-level priority:
+        //   1. gatewayHost (explicit override)
+        //   2. host        (environment identity: 'web.portalhq.io' prod / 'web.portalhq.dev' staging)
+        //   3. DEFAULT_RPC_HOST (compile-time production fallback)
+        //
+        // `host` doubles as the RPC gateway domain in Portal deployments — the two are
+        // always on the same hostname per environment (confirmed in deploy configs).
+        // Deriving from `host` ensures staging callers don't silently RPC to production
+        // when only `host` is overridden. Explicit `gatewayHost` takes full precedence
+        // for custom domains or non-standard deployments.
+        const effectiveGatewayHost = gatewayHost !== null && gatewayHost !== void 0 ? gatewayHost : host;
+        // Resolve rpcConfig: undefined or {} → auto-generate from effectiveGatewayHost.
+        // An explicit non-empty map is used verbatim — no merging with defaults.
+        const resolvedRpcConfig = !rpcConfig || Object.keys(rpcConfig).length === 0
+            ? buildDefaultRpcConfig(effectiveGatewayHost)
+            : rpcConfig;
         this.apiKey = apiKey;
         this.authToken = authToken;
         this.authUrl = authUrl;
         this.autoApprove = autoApprove;
-        this._rpcConfig = rpcConfig;
+        this._rpcConfig = resolvedRpcConfig;
         this._iframeRpcConfig = iframeRpcConfig;
         this.host = host;
         this.mpcHost = mpcHost;
@@ -172,6 +191,27 @@ class Portal {
             this.readyCallbacks = [];
         }
     }
+    onWalletNotOnDevice(callback) {
+        // Replay to late subscribers: if the event already fired, deliver immediately.
+        if (this.lastWalletNotOnDevicePayload !== null) {
+            const cached = this.lastWalletNotOnDevicePayload;
+            Promise.resolve()
+                .then(() => callback(cached))
+                .catch((err) => sdkLogger.warn('[Portal] onWalletNotOnDevice callback failed:', err));
+        }
+        this.walletNotOnDeviceCallbacks.push(callback);
+        return () => {
+            this.walletNotOnDeviceCallbacks = this.walletNotOnDeviceCallbacks.filter((cb) => cb !== callback);
+        };
+    }
+    triggerWalletNotOnDevice(payload) {
+        this.lastWalletNotOnDevicePayload = payload;
+        this.walletNotOnDeviceCallbacks.forEach((callback) => {
+            Promise.resolve()
+                .then(() => callback(payload))
+                .catch((err) => sdkLogger.warn('[Portal] onWalletNotOnDevice callback failed:', err));
+        });
+    }
     /*****************************
      * Wallet Methods
      *****************************/
@@ -182,20 +222,20 @@ class Portal {
     }
     createWallet(progress = () => {
         // Noop
-    }) {
+    }, traceId) {
         return __awaiter(this, void 0, void 0, function* () {
             const address = yield this.mpc.generate({
                 host: this.host,
                 mpcVersion: this.mpcVersion,
                 featureFlags: this.featureFlags,
-            }, progress);
+            }, progress, traceId);
             this.address = address;
             return address;
         });
     }
     generateBackupShare(progress = () => {
         // Noop
-    }) {
+    }, traceId) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.mpc.backup({
                 backupMethod: BackupMethods.passkey,
@@ -205,7 +245,7 @@ class Portal {
                 host: this.host,
                 mpcVersion: this.mpcVersion,
                 featureFlags: this.featureFlags,
-            }, progress);
+            }, progress, traceId);
             if (!response.encryptionKey) {
                 throw new Error('[Portal] Passkey backup did not return an encryption key. Please ensure you are using the latest iframe bundle.');
             }
@@ -268,17 +308,17 @@ class Portal {
     }
     backupWithPasskey(options = {}, progress = () => {
         // Noop
-    }) {
+    }, traceId) {
         return __awaiter(this, void 0, void 0, function* () {
             const { usePopup = true, customDomain, relyingPartyName, backupMethod = BackupMethods.passkey, } = options;
             if (usePopup) {
-                yield this.backupWallet(backupMethod, progress, {});
+                yield this.backupWallet(backupMethod, progress, {}, traceId);
                 return;
             }
             if (backupMethod !== BackupMethods.passkey) {
                 throw new Error(`[Portal] Direct passkey backup currently supports only BackupMethods.passkey (received ${backupMethod}).`);
             }
-            const { cipherText, encryptionKey } = yield this.generateBackupShare(progress);
+            const { cipherText, encryptionKey } = yield this.generateBackupShare(progress, traceId);
             yield this.registerPasskeyAndStoreEncryptionKey(cipherText, encryptionKey, {
                 customDomain,
                 relyingPartyName,
@@ -292,7 +332,7 @@ class Portal {
     }
     backupWallet(backupMethod, progress = () => {
         // Noop
-    }, backupConfigs = {}) {
+    }, backupConfigs = {}, traceId) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.mpc.backup({
                 backupMethod,
@@ -300,13 +340,13 @@ class Portal {
                 host: this.host,
                 mpcVersion: this.mpcVersion,
                 featureFlags: this.featureFlags,
-            }, progress);
+            }, progress, traceId);
             return response;
         });
     }
     recoverWallet(cipherText, backupMethod, backupConfigs = {}, progress = () => {
         // Noop
-    }) {
+    }, traceId) {
         return __awaiter(this, void 0, void 0, function* () {
             const address = yield this.mpc.recover({
                 cipherText,
@@ -315,16 +355,16 @@ class Portal {
                 host: this.host,
                 mpcVersion: this.mpcVersion,
                 featureFlags: this.featureFlags,
-            }, progress);
+            }, progress, traceId);
             this.address = address;
             return address;
         });
     }
     provisionWallet(cipherText, backupMethod, backupConfigs, progress = () => {
         // Noop
-    }) {
+    }, traceId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.recoverWallet(cipherText, backupMethod, backupConfigs, progress);
+            return this.recoverWallet(cipherText, backupMethod, backupConfigs, progress, traceId);
         });
     }
     eject(backupMethod, backupConfigs, orgBackupShare = '', clientBackupCipherText = '') {
@@ -1345,9 +1385,8 @@ class Portal {
             ethereum: 'eip155:1',
             sepolia: 'eip155:11155111',
             base: 'eip155:8453',
-            'base-sepolia': 'eip155:84531',
+            'base-sepolia': 'eip155:84532',
             polygon: 'eip155:137',
-            'polygon-mumbai': 'eip155:80001',
             'polygon-amoy': 'eip155:80002',
             solana: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
             'solana-devnet': 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
@@ -1412,6 +1451,7 @@ class Portal {
 }
 export { MpcError, MpcErrorCodes } from './mpc';
 export { PortalMpcError } from './mpc/errors';
+export { buildDefaultRpcConfig, DEFAULT_RPC_HOST } from './shared/rpc/defaults';
 export { RequestMethod } from './provider';
 export var MpcStatuses;
 (function (MpcStatuses) {

package/lib/esm/index.test.js

@@ -60,7 +60,7 @@ describe('Portal', () => {
                 host: 'web.portalhq.io',
                 mpcVersion: 'v6',
                 featureFlags: {},
-            }, mockProgressFn);
+            }, mockProgressFn, undefined);
         }));
         it('should successfully generate a wallet and call mpc.generate correctly with custom constructor args', () => __awaiter(void 0, void 0, void 0, function* () {
             portal = new Portal({
@@ -78,7 +78,13 @@ describe('Portal', () => {
                 host: 'test-host',
                 mpcVersion: 'v6',
                 featureFlags: { isMultiBackupEnabled: true },
-            }, mockProgressFn);
+            }, mockProgressFn, undefined);
+        }));
+        it('should pass caller-supplied traceId to mpc.generate', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockProgressFn = jest.fn();
+            const callerTraceId = 'test-trace-id-create';
+            yield portal.createWallet(mockProgressFn, callerTraceId);
+            expect(portal.mpc.generate).toHaveBeenCalledWith(expect.any(Object), mockProgressFn, callerTraceId);
         }));
     });
     describe('backupWallet', () => {
@@ -93,7 +99,7 @@ describe('Portal', () => {
                 host: 'web.portalhq.io',
                 mpcVersion: 'v6',
                 featureFlags: {},
-            }, mockProgressFn);
+            }, mockProgressFn, undefined);
         }));
         it('should successfully backup a wallet and call mpc.backup correctly with custom constructor args', () => __awaiter(void 0, void 0, void 0, function* () {
             portal = new Portal({
@@ -113,7 +119,13 @@ describe('Portal', () => {
                 host: 'test-host',
                 mpcVersion: 'v6',
                 featureFlags: { isMultiBackupEnabled: true },
-            }, mockProgressFn);
+            }, mockProgressFn, undefined);
+        }));
+        it('should pass caller-supplied traceId to mpc.backup', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockProgressFn = jest.fn();
+            const callerTraceId = 'test-trace-id-backup';
+            yield portal.backupWallet(BackupMethods.gdrive, mockProgressFn, mockBackupConfig, callerTraceId);
+            expect(portal.mpc.backup).toHaveBeenCalledWith(expect.any(Object), mockProgressFn, callerTraceId);
         }));
     });
     describe('generateBackupShare', () => {
@@ -137,7 +149,7 @@ describe('Portal', () => {
                 host: 'web.portalhq.io',
                 mpcVersion: 'v6',
                 featureFlags: {},
-            }, expect.any(Function));
+            }, expect.any(Function), undefined);
         }));
         it('should throw if the iframe response does not contain an encryption key', () => __awaiter(void 0, void 0, void 0, function* () {
             ;
@@ -147,6 +159,16 @@ describe('Portal', () => {
             });
             yield expect(portal.generateBackupShare()).rejects.toThrow('Passkey backup did not return an encryption key');
         }));
+        it('should pass caller-supplied traceId to mpc.backup', () => __awaiter(void 0, void 0, void 0, function* () {
+            const callerTraceId = 'test-trace-id-gen-backup';
+            portal.mpc.backup.mockResolvedValueOnce({
+                cipherText: mockCipherText,
+                encryptionKey: 'manual-key',
+                storageCallback: jest.fn(),
+            });
+            yield portal.generateBackupShare(undefined, callerTraceId);
+            expect(portal.mpc.backup).toHaveBeenCalledWith(expect.any(Object), expect.any(Function), callerTraceId);
+        }));
     });
     describe('registerPasskeyAndStoreEncryptionKey', () => {
         it('should delegate to the passkey service with computed relying party data', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -232,7 +254,7 @@ describe('Portal', () => {
                 host: 'web.portalhq.io',
                 mpcVersion: 'v6',
                 featureFlags: {},
-            }, progress);
+            }, progress, undefined);
         }));
     });
     describe('recoverWallet', () => {
@@ -248,7 +270,7 @@ describe('Portal', () => {
                 host: 'web.portalhq.io',
                 mpcVersion: 'v6',
                 featureFlags: {},
-            }, mockProgressFn);
+            }, mockProgressFn, undefined);
         }));
         it('should successfully recover a wallet and call mpc.recover correctly with custom constructor args', () => __awaiter(void 0, void 0, void 0, function* () {
             portal = new Portal({
@@ -269,7 +291,13 @@ describe('Portal', () => {
                 host: 'test-host',
                 mpcVersion: 'v6',
                 featureFlags: { isMultiBackupEnabled: true },
-            }, mockProgressFn);
+            }, mockProgressFn, undefined);
+        }));
+        it('should pass caller-supplied traceId to mpc.recover', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockProgressFn = jest.fn();
+            const callerTraceId = 'test-trace-id-recover';
+            yield portal.recoverWallet(mockCipherText, BackupMethods.password, mockBackupConfig, mockProgressFn, callerTraceId);
+            expect(portal.mpc.recover).toHaveBeenCalledWith(expect.any(Object), mockProgressFn, callerTraceId);
         }));
     });
     describe('provisionWallet', () => {
@@ -285,7 +313,7 @@ describe('Portal', () => {
                 host: 'web.portalhq.io',
                 mpcVersion: 'v6',
                 featureFlags: {},
-            }, mockProgressFn);
+            }, mockProgressFn, undefined);
         }));
         it('should successfully generate a wallet and call mpc.recover correctly with custom constructor args', () => __awaiter(void 0, void 0, void 0, function* () {
             portal = new Portal({
@@ -306,7 +334,7 @@ describe('Portal', () => {
                 host: 'test-host',
                 mpcVersion: 'v6',
                 featureFlags: { isMultiBackupEnabled: true },
-            }, mockProgressFn);
+            }, mockProgressFn, undefined);
         }));
     });
     describe('eject', () => {
@@ -1001,4 +1029,17 @@ describe('Portal', () => {
             expect(portal.iframeRpcConfig).toEqual(iframeRpcConfig);
         });
     });
+    describe('onWalletNotOnDevice', () => {
+        it('returns an unsubscribe function that stops the callback from firing', () => {
+            const callback = jest.fn();
+            const unsubscribe = portal.onWalletNotOnDevice(callback);
+            unsubscribe();
+            portal.triggerWalletNotOnDevice({
+                clientId: 'test-client',
+                isBackedUp: false,
+                reason: 'storage_cleared',
+            });
+            expect(callback).not.toHaveBeenCalled();
+        });
+    });
 });

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

@@ -1,6 +1,8 @@
+import Meld from './meld';
 import Noah from './noah';
 export default class Ramps {
     constructor({ mpc }) {
+        this.meld = new Meld({ mpc });
         this.noah = new Noah({ mpc });
     }
 }

package/lib/esm/integrations/ramps/meld/index.js

@@ -0,0 +1,118 @@
+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());
+    });
+};
+/**
+ * Meld fiat on-ramp API on `portal.ramps.meld`.
+ * Each method forwards to the embedded Portal iframe, which calls connect-api.
+ */
+export default class Meld {
+    constructor({ mpc }) {
+        this.mpc = mpc;
+    }
+    /** Register a new Meld customer for the authenticated client. */
+    createCustomer(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldCreateCustomer(data);
+        });
+    }
+    /** Retrieve the Meld customer record for the authenticated client. */
+    searchCustomer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldSearchCustomer();
+        });
+    }
+    /** Get fiat-to-crypto purchase quotes from Meld service providers. */
+    getRetailQuote(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetRetailQuote(data);
+        });
+    }
+    /**
+     * Create a Meld-hosted retail widget session.
+     * The response contains `data.widgetUrl` — open this URL in a new browser tab
+     * to let the user complete the purchase or KYC flow on the Meld-hosted page.
+     */
+    createRetailWidget(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldCreateRetailWidget(data);
+        });
+    }
+    /** Search retail transactions for the authenticated client. */
+    searchRetailTransactions(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldSearchRetailTransactions(data);
+        });
+    }
+    /** Get a single retail transaction by session ID. */
+    getRetailTransactionBySession(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetRetailTransactionBySession(sessionId);
+        });
+    }
+    /** Get a single retail transaction by transaction ID. */
+    getRetailTransaction(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetRetailTransaction(id);
+        });
+    }
+    /** Discover available Meld service providers. */
+    getServiceProviders(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetServiceProviders(params);
+        });
+    }
+    /** Discover supported countries. */
+    getCountries(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetCountries(params);
+        });
+    }
+    /** Discover supported fiat currencies. */
+    getFiatCurrencies(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetFiatCurrencies(params);
+        });
+    }
+    /** Discover supported crypto currencies. */
+    getCryptoCurrencies(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetCryptoCurrencies(params);
+        });
+    }
+    /** Discover supported payment methods. */
+    getPaymentMethods(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetPaymentMethods(params);
+        });
+    }
+    /** Discover default currency and payment method settings by country. */
+    getDefaults(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetDefaults(params);
+        });
+    }
+    /** Discover fiat currency purchase limits. */
+    getBuyLimits(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetBuyLimits(params);
+        });
+    }
+    /** Discover crypto currency sell limits. */
+    getSellLimits(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetSellLimits(params);
+        });
+    }
+    /** Discover KYC fiat level limits. */
+    getKycLimits(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mpc.meldGetKycLimits(params);
+        });
+    }
+}

package/lib/esm/integrations/ramps/meld/index.test.js

@@ -0,0 +1,157 @@
+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());
+    });
+};
+import Meld from '.';
+const mockMeldCreateCustomerResponse = {
+    data: { id: 'cust-1', accountId: 'acc-1', externalId: 'ext-1' },
+};
+const mockMeldSearchCustomerResponse = {
+    data: { customers: [], count: 0, remaining: 0 },
+};
+const mockMeldGetRetailQuoteResponse = {
+    data: { quotes: [] },
+};
+const mockMeldCreateRetailWidgetResponse = {
+    data: { id: 'sess-1', token: 'tok-1', customerId: 'cust-1', externalCustomerId: 'ext-1', externalSessionId: 'ses-1', widgetUrl: 'https://widget.meld.io' },
+};
+const mockMeldSearchRetailTransactionsResponse = {
+    data: { transactions: [], count: 0, remaining: 0, totalCount: 0 },
+};
+const mockMeldGetRetailTransactionResponse = {
+    data: { transaction: { id: 'tx-1', sessionId: 'ses-1', status: 'COMPLETED', transactionType: 'BUY', serviceProvider: 'STRIPE', createdAt: '2024-01-01', updatedAt: '2024-01-01' } },
+};
+const mockMeldDiscoveryResponse = { data: [] };
+const buildMpcMock = () => ({
+    meldCreateCustomer: jest.fn().mockResolvedValue(mockMeldCreateCustomerResponse),
+    meldSearchCustomer: jest.fn().mockResolvedValue(mockMeldSearchCustomerResponse),
+    meldGetRetailQuote: jest.fn().mockResolvedValue(mockMeldGetRetailQuoteResponse),
+    meldCreateRetailWidget: jest.fn().mockResolvedValue(mockMeldCreateRetailWidgetResponse),
+    meldSearchRetailTransactions: jest.fn().mockResolvedValue(mockMeldSearchRetailTransactionsResponse),
+    meldGetRetailTransactionBySession: jest.fn().mockResolvedValue(mockMeldGetRetailTransactionResponse),
+    meldGetRetailTransaction: jest.fn().mockResolvedValue(mockMeldGetRetailTransactionResponse),
+    meldGetServiceProviders: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+    meldGetCountries: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+    meldGetFiatCurrencies: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+    meldGetCryptoCurrencies: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+    meldGetPaymentMethods: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+    meldGetDefaults: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+    meldGetBuyLimits: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+    meldGetSellLimits: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+    meldGetKycLimits: jest.fn().mockResolvedValue(mockMeldDiscoveryResponse),
+});
+describe('Meld', () => {
+    let mpcMock;
+    let meld;
+    beforeEach(() => {
+        mpcMock = buildMpcMock();
+        meld = new Meld({ mpc: mpcMock });
+    });
+    it('createCustomer delegates to mpc.meldCreateCustomer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const req = { email: 'user@example.com', type: 'INDIVIDUAL' };
+        const result = yield meld.createCustomer(req);
+        expect(mpcMock.meldCreateCustomer).toHaveBeenCalledWith(req);
+        expect(result).toEqual(mockMeldCreateCustomerResponse);
+    }));
+    it('searchCustomer delegates to mpc.meldSearchCustomer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.searchCustomer();
+        expect(mpcMock.meldSearchCustomer).toHaveBeenCalled();
+        expect(result).toEqual(mockMeldSearchCustomerResponse);
+    }));
+    it('getRetailQuote delegates to mpc.meldGetRetailQuote', () => __awaiter(void 0, void 0, void 0, function* () {
+        const req = { countryCode: 'US', sourceCurrencyCode: 'USD', destinationCurrencyCode: 'ETH', sourceAmount: 100 };
+        const result = yield meld.getRetailQuote(req);
+        expect(mpcMock.meldGetRetailQuote).toHaveBeenCalledWith(req);
+        expect(result).toEqual(mockMeldGetRetailQuoteResponse);
+    }));
+    it('createRetailWidget delegates to mpc.meldCreateRetailWidget', () => __awaiter(void 0, void 0, void 0, function* () {
+        const req = {
+            sessionType: 'BUY',
+            sessionData: {
+                countryCode: 'US',
+                serviceProvider: 'STRIPE',
+                sourceCurrencyCode: 'USD',
+                sourceAmount: '100',
+                destinationCurrencyCode: 'ETH',
+            },
+        };
+        const result = yield meld.createRetailWidget(req);
+        expect(mpcMock.meldCreateRetailWidget).toHaveBeenCalledWith(req);
+        expect(result).toEqual(mockMeldCreateRetailWidgetResponse);
+    }));
+    it('searchRetailTransactions delegates to mpc.meldSearchRetailTransactions without params', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.searchRetailTransactions();
+        expect(mpcMock.meldSearchRetailTransactions).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldSearchRetailTransactionsResponse);
+    }));
+    it('searchRetailTransactions delegates with params when provided', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = { status: 'COMPLETED' };
+        yield meld.searchRetailTransactions(params);
+        expect(mpcMock.meldSearchRetailTransactions).toHaveBeenCalledWith(params);
+    }));
+    it('getRetailTransactionBySession delegates to mpc.meldGetRetailTransactionBySession', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getRetailTransactionBySession('ses-1');
+        expect(mpcMock.meldGetRetailTransactionBySession).toHaveBeenCalledWith('ses-1');
+        expect(result).toEqual(mockMeldGetRetailTransactionResponse);
+    }));
+    it('getRetailTransaction delegates to mpc.meldGetRetailTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getRetailTransaction('tx-1');
+        expect(mpcMock.meldGetRetailTransaction).toHaveBeenCalledWith('tx-1');
+        expect(result).toEqual(mockMeldGetRetailTransactionResponse);
+    }));
+    it('getServiceProviders delegates to mpc.meldGetServiceProviders', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = { countries: 'US' };
+        const result = yield meld.getServiceProviders(params);
+        expect(mpcMock.meldGetServiceProviders).toHaveBeenCalledWith(params);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+    it('getServiceProviders without params delegates undefined', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield meld.getServiceProviders();
+        expect(mpcMock.meldGetServiceProviders).toHaveBeenCalledWith(undefined);
+    }));
+    it('getCountries delegates to mpc.meldGetCountries', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getCountries();
+        expect(mpcMock.meldGetCountries).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+    it('getFiatCurrencies delegates to mpc.meldGetFiatCurrencies', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getFiatCurrencies();
+        expect(mpcMock.meldGetFiatCurrencies).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+    it('getCryptoCurrencies delegates to mpc.meldGetCryptoCurrencies', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getCryptoCurrencies();
+        expect(mpcMock.meldGetCryptoCurrencies).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+    it('getPaymentMethods delegates to mpc.meldGetPaymentMethods', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getPaymentMethods();
+        expect(mpcMock.meldGetPaymentMethods).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+    it('getDefaults delegates to mpc.meldGetDefaults', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getDefaults();
+        expect(mpcMock.meldGetDefaults).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+    it('getBuyLimits delegates to mpc.meldGetBuyLimits', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getBuyLimits();
+        expect(mpcMock.meldGetBuyLimits).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+    it('getSellLimits delegates to mpc.meldGetSellLimits', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getSellLimits();
+        expect(mpcMock.meldGetSellLimits).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+    it('getKycLimits delegates to mpc.meldGetKycLimits', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield meld.getKycLimits();
+        expect(mpcMock.meldGetKycLimits).toHaveBeenCalledWith(undefined);
+        expect(result).toEqual(mockMeldDiscoveryResponse);
+    }));
+});

package/lib/esm/integrations/ramps/noah/index.js

@@ -64,9 +64,9 @@ export default class Noah {
         });
     }
     /** Pay-in payment methods available to the customer. */
-    getPaymentMethods() {
+    getPaymentMethods(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mpc.getPaymentMethods();
+            return this.mpc.getPaymentMethods(data);
         });
     }
 }

package/lib/esm/integrations/ramps/noah/index.test.js

@@ -64,11 +64,15 @@ describe('Noah', () => {
         const spy = jest.spyOn(mpc, 'initiatePayin').mockResolvedValue({
             data: {
                 payinId: 'p1',
+                cryptoCurrency: 'USDC_TEST',
+                fee: { fiatCurrencyCode: 'USD', totalFeePct: '0', totalFeeBase: '0', totalFeeMin: '0' },
                 bankDetails: {
                     paymentMethodId: 'pm-123',
-                    paymentMethodType: 'bank_account',
+                    paymentMethodType: 'BankLocal',
                     accountNumber: '1234567890',
+                    cryptoCurrency: 'USDC_TEST',
                     network: 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+                    fee: { fiatCurrencyCode: 'USD', totalFeePct: '0', totalFeeBase: '0', totalFeeMin: '0' },
                 },
             },
         });
@@ -130,6 +134,7 @@ describe('Noah', () => {
                 payoutId: 'out-1',
                 formSessionId: 'fs-1',
                 cryptoAmountEstimate: '10',
+                cryptoAuthorizedAmount: '10',
                 totalFee: '0.01',
             },
         });
@@ -158,7 +163,11 @@ describe('Noah', () => {
         const spy = jest.spyOn(mpc, 'getPaymentMethods').mockResolvedValue({
             data: { paymentMethods: [] },
         });
-        yield noah.getPaymentMethods();
+        yield noah.getPaymentMethods({
+            pageSize: 50,
+            pageToken: 'token-123',
+            capability: 'PayoutFrom',
+        });
         expect(spy).toHaveBeenCalled();
     }));
 });