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

package/lib/esm/provider/index.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { ProviderRpcError, RpcErrorCodes } from './errors';
 import { sdkLogger } from '../logger';
 import { generateTraceId, X_PORTAL_TRACE_ID_HEADER } from '../shared/trace';
+import { isPortalHostedUrl } from '../shared/rpc/auth';
 export var RequestMethod;
 (function (RequestMethod) {
     RequestMethod["eth_accounts"] = "eth_accounts";
@@ -131,6 +132,7 @@ export var RequestMethod;
     RequestMethod["sol_signTransaction"] = "sol_signTransaction";
     // TRON Wallet Methods
     RequestMethod["tron_sendTransaction"] = "tron_sendTransaction";
+    RequestMethod["tron_signTypedData"] = "tron_signTypedData";
 })(RequestMethod || (RequestMethod = {}));
 const passiveSignerMethods = [
     RequestMethod.eth_accounts,
@@ -153,6 +155,7 @@ const signerMethods = [
     RequestMethod.sol_signMessage,
     RequestMethod.sol_signTransaction,
     RequestMethod.tron_sendTransaction,
+    RequestMethod.tron_signTypedData,
 ];
 const iframeProxiedMethodStrings = [
     'eth_getTransactionReceipt',
@@ -200,6 +203,31 @@ class Provider {
                         params = [txParams];
                     }
                     break;
+                case RequestMethod.tron_signTypedData: {
+                    const data = Array.isArray(txParams) ? txParams[0] : txParams;
+                    let parsed;
+                    if (typeof data === 'string') {
+                        try {
+                            parsed = JSON.parse(data);
+                        }
+                        catch (_a) {
+                            throw new Error('[PortalProvider] tron_signTypedData params must be valid JSON');
+                        }
+                        params = data;
+                    }
+                    else {
+                        parsed = data;
+                        params = JSON.stringify(data, (_key, value) => typeof value === 'bigint' ? value.toString() : value);
+                    }
+                    if (typeof parsed !== 'object' ||
+                        parsed === null ||
+                        !('domain' in parsed) ||
+                        !('types' in parsed) ||
+                        !('value' in parsed)) {
+                        throw new Error('[PortalProvider] tron_signTypedData params must include "domain", "types", and "value"');
+                    }
+                    break;
+                }
                 default:
                     if (Array.isArray(txParams)) {
                         params = txParams[0];
@@ -401,6 +429,7 @@ class Provider {
      * @returns Promise<any>
      */
     handleGatewayRequest({ chainId, method, params, traceId, }) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (iframeProxiedMethodStrings.includes(method)) {
                 sdkLogger.info(`[PortalProvider] routing ${method} through iframe (chainId=${String(chainId)})`, { traceId });
@@ -414,6 +443,7 @@ class Provider {
                     chainId: chainId,
                 }, { traceId });
             }
+            const rpcUrl = this.portal.getRpcUrl(chainId);
             const requestBody = {
                 body: JSON.stringify({
                     jsonrpc: '2.0',
@@ -422,9 +452,11 @@ class Provider {
                     params,
                 }),
                 method: 'POST',
-                headers: Object.assign({ 'Content-Type': 'application/json' }, (traceId && { [X_PORTAL_TRACE_ID_HEADER]: traceId })),
+                headers: Object.assign(Object.assign({ 'Content-Type': 'application/json' }, (isPortalHostedUrl(rpcUrl) && ((_a = this.portal.apiKey) !== null && _a !== void 0 ? _a : this.portal.authToken)
+                    ? { Authorization: `Bearer ${(_b = this.portal.apiKey) !== null && _b !== void 0 ? _b : this.portal.authToken}` }
+                    : {})), (traceId && { [X_PORTAL_TRACE_ID_HEADER]: traceId })),
             };
-            const result = yield fetch(this.portal.getRpcUrl(chainId), requestBody);
+            const result = yield fetch(rpcUrl, requestBody);
             return result.json();
         });
     }
@@ -486,6 +518,16 @@ class Provider {
                     })));
                     return result;
                 }
+                case RequestMethod.tron_signTypedData: {
+                    this.enforceTronChainId(chainId);
+                    const result = yield this.portal.mpc.sign(Object.assign({ chainId: chainId, method, params: this.buildParams(method, params), 
+                        // tron_signTypedData is a sign-only method; MPC does not require an RPC client for it
+                        rpcUrl: '', sponsorGas,
+                        traceId }, (signatureApprovalMemo !== undefined && {
+                        signatureApprovalMemo,
+                    })));
+                    return result;
+                }
                 default:
                     throw new Error('[PortalProvider] Method "' + method + '" not supported');
             }

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

@@ -10,6 +10,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 portal from '../__mocks/portal/portal';
 import Provider from '.';
 import { mockRpcUrl, mockSignedHash } from '../__mocks/constants';
@@ -582,6 +593,118 @@ describe('Provider', () => {
                     });
                 }));
             });
+            describe('tron_signTypedData', () => {
+                const mockTypedData = {
+                    domain: { name: 'Permit2', version: '1', chainId: 3448148188 },
+                    types: {
+                        TokenPermissions: [
+                            { name: 'token', type: 'address' },
+                            { name: 'amount', type: 'uint256' },
+                        ],
+                    },
+                    value: { token: 'TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf', amount: '1000000' },
+                };
+                it('should throw an error if no chainId is provided alongside tron_signTypedData', () => __awaiter(void 0, void 0, void 0, function* () {
+                    yield expect(provider.request({
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    })).rejects.toThrow(new Error('[PortalProvider] Chain ID is required for the operation'));
+                }));
+                it('should throw an error if malformed chainId is provided alongside tron_signTypedData', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    yield expect(provider.request({
+                        chainId,
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    })).rejects.toThrow(new Error(`[PortalProvider] Chain ID must be prefixed with "tron:" for the operation, got ${chainId}`));
+                }));
+                it('should successfully handle a tron_signTypedData request with object params', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(result).toEqual(mockSignedHash);
+                    expect(portal.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: JSON.stringify(mockTypedData),
+                        rpcUrl: '',
+                        sponsorGas: undefined,
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a tron_signTypedData request with pre-stringified params', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const stringifiedData = JSON.stringify(mockTypedData);
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [stringifiedData],
+                    });
+                    expect(result).toEqual(mockSignedHash);
+                    expect(portal.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: stringifiedData,
+                        rpcUrl: '',
+                        sponsorGas: undefined,
+                        traceId: 'mock-trace-id-12345',
+                    });
+                }));
+                it('should throw if params is an invalid JSON string', () => __awaiter(void 0, void 0, void 0, function* () {
+                    yield expect(provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: ['not valid json {'],
+                    })).rejects.toThrow('[PortalProvider] tron_signTypedData params must be valid JSON');
+                }));
+                it('should throw if object params is missing "domain"', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { domain: _omitted } = mockTypedData, withoutDomain = __rest(mockTypedData, ["domain"]);
+                    yield expect(provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [withoutDomain],
+                    })).rejects.toThrow('[PortalProvider] tron_signTypedData params must include "domain", "types", and "value"');
+                }));
+                it('should throw if object params is missing "types"', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { types: _omitted } = mockTypedData, withoutTypes = __rest(mockTypedData, ["types"]);
+                    yield expect(provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [withoutTypes],
+                    })).rejects.toThrow('[PortalProvider] tron_signTypedData params must include "domain", "types", and "value"');
+                }));
+                it('should throw if object params is missing "value"', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { value: _omitted } = mockTypedData, withoutValue = __rest(mockTypedData, ["value"]);
+                    yield expect(provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [withoutValue],
+                    })).rejects.toThrow('[PortalProvider] tron_signTypedData params must include "domain", "types", and "value"');
+                }));
+                it('should throw if pre-stringified params is missing "types"', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const { types: _omitted } = mockTypedData, withoutTypes = __rest(mockTypedData, ["types"]);
+                    yield expect(provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [JSON.stringify(withoutTypes)],
+                    })).rejects.toThrow('[PortalProvider] tron_signTypedData params must include "domain", "types", and "value"');
+                }));
+                it('should not require an rpcUrl (sends empty string)', () => __awaiter(void 0, void 0, void 0, function* () {
+                    yield provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(portal.mpc.sign).toHaveBeenCalledWith(expect.objectContaining({ rpcUrl: '' }));
+                }));
+            });
         });
         describe('Signer methods without auto-approval', () => {
             const mockSigningRequestedHandler = jest.fn();
@@ -1286,6 +1409,69 @@ describe('Provider', () => {
                     expect(mockConsoleWarn).toHaveBeenCalledWith("[PortalProvider] Request for signing method 'tron_sendTransaction' could not be completed because it was not approved by the user.");
                 }));
             });
+            describe('tron_signTypedData', () => {
+                const mockTypedData = {
+                    domain: { name: 'Permit2', version: '1', chainId: 3448148188 },
+                    types: {
+                        TokenPermissions: [
+                            { name: 'token', type: 'address' },
+                            { name: 'amount', type: 'uint256' },
+                        ],
+                    },
+                    value: { token: 'TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf', amount: '1000000' },
+                };
+                it('should successfully handle an approved tron_signTypedData request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: RequestMethod.tron_signTypedData,
+                            params: [mockTypedData],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(result).toEqual(mockSignedHash);
+                    expect(portal.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: JSON.stringify(mockTypedData),
+                        rpcUrl: '',
+                        sponsorGas: undefined,
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected tron_signTypedData request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: RequestMethod.tron_signTypedData,
+                            params: [mockTypedData],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(result).toEqual(undefined);
+                    expect(mockConsoleWarn).toHaveBeenCalledWith("[PortalProvider] Request for signing method 'tron_signTypedData' could not be completed because it was not approved by the user.");
+                }));
+            });
         });
         describe('Non-signer methods', () => {
             beforeAll(() => {

package/lib/esm/rpc.test.js

@@ -0,0 +1,157 @@
+/**
+ * @jest-environment jsdom
+ */
+import { isPortalHostedUrl } from './shared/rpc/auth';
+import { buildDefaultRpcConfig, DEFAULT_RPC_HOST } from './shared/rpc/defaults';
+import Portal from '.';
+// ─── isPortalHostedUrl ───────────────────────────────────────────────────────
+describe('isPortalHostedUrl', () => {
+    describe('trusted Portal domains', () => {
+        const trusted = [
+            'https://web.portalhq.io/rpc/v1/eip155/1',
+            'https://portalhq.io',
+            'https://staging.portalhq.io/rpc/v1/eip155/1',
+            'https://x.portalhq.io',
+            'https://web.portalhq.dev/rpc/v1/eip155/1',
+            'https://portalhq.dev',
+            'https://sub.portalhq.dev',
+            'https://portalhq-passkey.io',
+            'https://sub.portalhq-passkey.io',
+            'https://portalhq-passkey.dev',
+            'https://sub.portalhq-passkey.dev',
+        ];
+        for (const url of trusted) {
+            it(`returns true for ${url}`, () => {
+                expect(isPortalHostedUrl(url)).toBe(true);
+            });
+        }
+    });
+    describe('untrusted / third-party domains', () => {
+        const untrusted = [
+            'https://mainnet.infura.io/v3/KEY',
+            'https://eth-mainnet.alchemyapi.io/v2/KEY',
+            'https://rpc.ankr.com/eth',
+            'https://notportalhq.io/rpc/v1/eip155/1',
+            'https://portalhq.io.evil.com/rpc',
+            'https://evil-portalhq.io/rpc',
+            'https://portalhq.iomalicious.com',
+            'http://localhost:8545',
+            'http://127.0.0.1:8545',
+        ];
+        for (const url of untrusted) {
+            it(`returns false for ${url}`, () => {
+                expect(isPortalHostedUrl(url)).toBe(false);
+            });
+        }
+    });
+    it('returns false for an invalid URL', () => {
+        expect(isPortalHostedUrl('not-a-url')).toBe(false);
+        expect(isPortalHostedUrl('')).toBe(false);
+    });
+    it('handles trailing dot in hostname (valid DNS normalisation)', () => {
+        // 'web.portalhq.io.' is technically valid DNS — must still be trusted
+        expect(isPortalHostedUrl('https://web.portalhq.io./rpc/v1/eip155/1')).toBe(true);
+    });
+});
+// ─── buildDefaultRpcConfig ───────────────────────────────────────────────────
+describe('buildDefaultRpcConfig', () => {
+    it('returns exactly 13 entries', () => {
+        expect(Object.keys(buildDefaultRpcConfig(DEFAULT_RPC_HOST))).toHaveLength(13);
+    });
+    it('includes all 11 expected EVM chains', () => {
+        const cfg = buildDefaultRpcConfig(DEFAULT_RPC_HOST);
+        const evmChains = [
+            'eip155:1',
+            'eip155:11155111',
+            'eip155:137',
+            'eip155:80002',
+            'eip155:8453',
+            'eip155:84532',
+            'eip155:143',
+            'eip155:10143',
+            'eip155:10',
+            'eip155:42161',
+            'eip155:43114',
+        ];
+        for (const chain of evmChains) {
+            expect(cfg).toHaveProperty(chain);
+        }
+    });
+    it('includes both Solana chains', () => {
+        const cfg = buildDefaultRpcConfig(DEFAULT_RPC_HOST);
+        expect(cfg).toHaveProperty('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp');
+        expect(cfg).toHaveProperty('solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1');
+    });
+    it('does NOT include deprecated Polygon Mumbai (eip155:80001)', () => {
+        expect(buildDefaultRpcConfig(DEFAULT_RPC_HOST)).not.toHaveProperty('eip155:80001');
+    });
+    it('every URL follows the template https://{rpcHost}/rpc/v1/{namespace}/{reference}', () => {
+        const cfg = buildDefaultRpcConfig(DEFAULT_RPC_HOST);
+        for (const [chainId, url] of Object.entries(cfg)) {
+            const [namespace, reference] = chainId.split(':');
+            expect(url).toBe(`https://${DEFAULT_RPC_HOST}/rpc/v1/${namespace}/${reference}`);
+        }
+    });
+    it('uses the production host by default', () => {
+        const cfg = buildDefaultRpcConfig();
+        expect(cfg['eip155:1']).toBe('https://web.portalhq.io/rpc/v1/eip155/1');
+    });
+    it('uses a custom rpcHost when provided', () => {
+        const cfg = buildDefaultRpcConfig('web.portalhq.dev');
+        for (const url of Object.values(cfg)) {
+            expect(url).toContain('https://web.portalhq.dev/rpc/v1/');
+        }
+        expect(cfg['eip155:1']).toBe('https://web.portalhq.dev/rpc/v1/eip155/1');
+    });
+    it('does not contain the production host when a custom host is used', () => {
+        const cfg = buildDefaultRpcConfig('web.portalhq.dev');
+        for (const url of Object.values(cfg)) {
+            expect(url).not.toContain(DEFAULT_RPC_HOST);
+        }
+    });
+});
+// ─── Portal constructor — rpcConfig resolution ───────────────────────────────
+describe('Portal constructor — rpcConfig resolution', () => {
+    it('generates 13 default chains when rpcConfig is omitted', () => {
+        const portal = new Portal({ apiKey: 'test-key' });
+        expect(Object.keys(portal.rpcConfig)).toHaveLength(13);
+    });
+    it('uses web.portalhq.io gateway URLs when rpcConfig is omitted', () => {
+        const portal = new Portal({ apiKey: 'test-key' });
+        expect(portal.rpcConfig['eip155:1']).toBe('https://web.portalhq.io/rpc/v1/eip155/1');
+    });
+    it('treats {} identically to omitting rpcConfig', () => {
+        const portalA = new Portal({ apiKey: 'test-key' });
+        const portalB = new Portal({ apiKey: 'test-key', rpcConfig: {} });
+        expect(portalB.rpcConfig).toEqual(portalA.rpcConfig);
+    });
+    it('uses an explicit non-empty rpcConfig verbatim (no merge with defaults)', () => {
+        const custom = { 'eip155:1': 'https://my-node.example.com/eth' };
+        const portal = new Portal({ apiKey: 'test-key', rpcConfig: custom });
+        expect(portal.rpcConfig).toEqual(custom);
+        expect(Object.keys(portal.rpcConfig)).toHaveLength(1);
+    });
+    it('does not inject defaults alongside an explicit config', () => {
+        const custom = { 'eip155:1': 'https://my-node.example.com/eth' };
+        const portal = new Portal({ apiKey: 'test-key', rpcConfig: custom });
+        expect(portal.rpcConfig['eip155:137']).toBeUndefined();
+    });
+    it('uses a custom gatewayHost in the generated default URLs', () => {
+        const portal = new Portal({ apiKey: 'test-key', gatewayHost: 'web.portalhq.dev' });
+        expect(portal.rpcConfig['eip155:1']).toBe('https://web.portalhq.dev/rpc/v1/eip155/1');
+    });
+    it('all default URLs contain the custom gatewayHost', () => {
+        const portal = new Portal({ apiKey: 'test-key', gatewayHost: 'web.portalhq.dev' });
+        for (const url of Object.values(portal.rpcConfig)) {
+            expect(url).toContain('https://web.portalhq.dev/rpc/v1/');
+        }
+    });
+    it('getRpcUrl returns the default URL for a standard chain', () => {
+        const portal = new Portal({ apiKey: 'test-key' });
+        expect(portal.getRpcUrl('eip155:1')).toBe('https://web.portalhq.io/rpc/v1/eip155/1');
+    });
+    it('getRpcUrl throws for a chain not in the config', () => {
+        const portal = new Portal({ apiKey: 'test-key' });
+        expect(() => portal.getRpcUrl('eip155:99999')).toThrow();
+    });
+});

package/lib/esm/shared/rpc/auth.js

@@ -0,0 +1,25 @@
+const PORTAL_TRUSTED_DOMAINS = [
+    'portalhq.io',
+    'portalhq.dev',
+    'portalhq-passkey.io',
+    'portalhq-passkey.dev',
+];
+/**
+ * Returns true iff the URL's hostname is owned by Portal.
+ *
+ * Guards Authorization header injection — prevents credential leakage to
+ * third-party RPC providers (Infura, Alchemy, etc.).
+ *
+ * Localhost trust is intentionally excluded: that is an iframe-only
+ * concern (dev CORS proxies) and is handled separately in the iframe.
+ */
+export function isPortalHostedUrl(url) {
+    try {
+        // Normalise: strip trailing dots from hostname (valid DNS but unusual)
+        const hostname = new URL(url).hostname.toLowerCase().replace(/\.$/, '');
+        return PORTAL_TRUSTED_DOMAINS.some((domain) => hostname === domain || hostname.endsWith(`.${domain}`));
+    }
+    catch (_a) {
+        return false;
+    }
+}

package/lib/esm/shared/rpc/defaults.js

@@ -0,0 +1,36 @@
+/**
+ * Production Portal RPC gateway hostname.
+ * Staging equivalent: `web.portalhq.dev`.
+ * Used as the fallback when neither `gatewayHost` nor `host` is supplied.
+ */
+export const DEFAULT_RPC_HOST = 'web.portalhq.io';
+/**
+ * Builds the default Portal-managed RPC gateway config from a given gateway host.
+ *
+ * URL template: https://{rpcHost}/rpc/v1/{namespace}/{reference}
+ *
+ * Covers 13 chains — 11 EVM + 2 Solana. Polygon Amoy (eip155:80002) is used;
+ * the deprecated Mumbai (eip155:80001) is intentionally excluded.
+ *
+ * When rpcConfig is undefined or {} in the Portal constructor, this function is
+ * called automatically. An explicit non-empty rpcConfig always takes precedence
+ * verbatim — no merging with defaults.
+ */
+export function buildDefaultRpcConfig(rpcHost = DEFAULT_RPC_HOST) {
+    const base = `https://${rpcHost}/rpc/v1`;
+    return {
+        'eip155:1': `${base}/eip155/1`,
+        'eip155:11155111': `${base}/eip155/11155111`,
+        'eip155:137': `${base}/eip155/137`,
+        'eip155:80002': `${base}/eip155/80002`,
+        'eip155:8453': `${base}/eip155/8453`,
+        'eip155:84532': `${base}/eip155/84532`,
+        'eip155:143': `${base}/eip155/143`,
+        'eip155:10143': `${base}/eip155/10143`,
+        'eip155:10': `${base}/eip155/10`,
+        'eip155:42161': `${base}/eip155/42161`,
+        'eip155:43114': `${base}/eip155/43114`,
+        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp': `${base}/solana/5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`,
+        'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1': `${base}/solana/EtWTRABZaYq6iMfeYKouRu166VU2xqa1`,
+    };
+}

package/lib/esm/shared/types/index.js

@@ -14,6 +14,7 @@ export * from './yieldxyz';
 export * from './zero-x';
 export * from './lifi';
 export * from './noah';
+export * from './meld';
 export * from './hypernative';
 export * from './blockaid';
 // Account Abstraction types

package/lib/esm/shared/types/meld.js

@@ -0,0 +1 @@
+export {};

package/noah-types.d.ts

@@ -1,5 +1,6 @@
 export type {
   AccountHolderDetails,
+  AccountHolderName,
   AmountCondition,
   BankDetails,
   BankToAddressRelatedPaymentMethod,
@@ -7,8 +8,15 @@ export type {
   ChannelCalculated,
   ChannelLimits,
   DepositSourceTriggerCondition,
+  FiatPaymentMethodCategory,
+  FiatPaymentMethodDisplayType,
   FormNextStep,
   IssuerDetails,
+  NoahBankAddress,
+  NoahBusinessFee,
+  NoahComparisonOperator,
+  NoahFeeDetails,
+  NoahGetPaymentMethodsRequest,
   NoahGetPaymentMethodsResponse,
   NoahGetPaymentMethodsResponseData,
   NoahGetPayoutChannelFormResponse,
@@ -30,6 +38,13 @@ export type {
   NoahInitiatePayoutRequest,
   NoahInitiatePayoutResponse,
   NoahInitiatePayoutResponseData,
+  NoahOnchainDepositSourceTriggerInput,
+  NoahOnchainDepositSourceTriggerType,
+  NoahPaymentMethodType,
+  NoahPermanentOnchainDepositSourceTriggerInput,
+  NoahProcessingTier,
+  NoahQuotedOnchainDepositSourceTriggerInput,
+  NoahSellQuote,
   NoahSingleOnchainDepositSourceTriggerInput,
   NoahSimulatePayinRequest,
   NoahSimulatePayinResponse,
@@ -38,5 +53,6 @@ export type {
   PaymentMethod,
   PaymentMethodDetails,
   PortalApiSuccessEnvelope,
-  StreetAddress,
+  TransactionBreakdownItem,
+  TransactionBreakdownType,
 } from './src/shared/types/noah'

package/package.json

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