@portal-hq/web 3.17.0 → 3.18.0

package/lib/commonjs/provider/index.js

@@ -13,6 +13,7 @@ exports.RequestMethod = void 0;
 const errors_1 = require("./errors");
 const logger_1 = require("../logger");
 const trace_1 = require("../shared/trace");
+const auth_1 = require("../shared/rpc/auth");
 var RequestMethod;
 (function (RequestMethod) {
     RequestMethod["eth_accounts"] = "eth_accounts";
@@ -134,6 +135,7 @@ var RequestMethod;
     RequestMethod["sol_signTransaction"] = "sol_signTransaction";
     // TRON Wallet Methods
     RequestMethod["tron_sendTransaction"] = "tron_sendTransaction";
+    RequestMethod["tron_signTypedData"] = "tron_signTypedData";
 })(RequestMethod = exports.RequestMethod || (exports.RequestMethod = {}));
 const passiveSignerMethods = [
     RequestMethod.eth_accounts,
@@ -156,6 +158,7 @@ const signerMethods = [
     RequestMethod.sol_signMessage,
     RequestMethod.sol_signTransaction,
     RequestMethod.tron_sendTransaction,
+    RequestMethod.tron_signTypedData,
 ];
 const iframeProxiedMethodStrings = [
     'eth_getTransactionReceipt',
@@ -203,6 +206,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];
@@ -404,6 +432,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)) {
                 logger_1.sdkLogger.info(`[PortalProvider] routing ${method} through iframe (chainId=${String(chainId)})`, { traceId });
@@ -417,6 +446,7 @@ class Provider {
                     chainId: chainId,
                 }, { traceId });
             }
+            const rpcUrl = this.portal.getRpcUrl(chainId);
             const requestBody = {
                 body: JSON.stringify({
                     jsonrpc: '2.0',
@@ -425,9 +455,11 @@ class Provider {
                     params,
                 }),
                 method: 'POST',
-                headers: Object.assign({ 'Content-Type': 'application/json' }, (traceId && { [trace_1.X_PORTAL_TRACE_ID_HEADER]: traceId })),
+                headers: Object.assign(Object.assign({ 'Content-Type': 'application/json' }, ((0, auth_1.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 && { [trace_1.X_PORTAL_TRACE_ID_HEADER]: traceId })),
             };
-            const result = yield fetch(this.portal.getRpcUrl(chainId), requestBody);
+            const result = yield fetch(rpcUrl, requestBody);
             return result.json();
         });
     }
@@ -489,6 +521,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/commonjs/provider/index.test.js

@@ -11,6 +11,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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -587,6 +598,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: __1.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: __1.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: __1.RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: __1.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: __1.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: __1.RequestMethod.tron_signTypedData,
+                        params: [stringifiedData],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: __1.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: __1.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: __1.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: __1.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: __1.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: __1.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: __1.RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith(expect.objectContaining({ rpcUrl: '' }));
+                }));
+            });
         });
         describe('Signer methods without auto-approval', () => {
             const mockSigningRequestedHandler = jest.fn();
@@ -1291,6 +1414,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: __1.RequestMethod.tron_signTypedData,
+                            params: [mockTypedData],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_signTypedData,
+                        params: JSON.stringify(mockTypedData),
+                        rpcUrl: '',
+                        sponsorGas: undefined,
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: __1.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: __1.RequestMethod.tron_signTypedData,
+                            params: [mockTypedData],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_signTypedData,
+                        params: [mockTypedData],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.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/commonjs/rpc.test.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * @jest-environment jsdom
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_1 = require("./shared/rpc/auth");
+const defaults_1 = require("./shared/rpc/defaults");
+const _1 = __importDefault(require("."));
+// ─── 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((0, auth_1.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((0, auth_1.isPortalHostedUrl)(url)).toBe(false);
+            });
+        }
+    });
+    it('returns false for an invalid URL', () => {
+        expect((0, auth_1.isPortalHostedUrl)('not-a-url')).toBe(false);
+        expect((0, auth_1.isPortalHostedUrl)('')).toBe(false);
+    });
+    it('handles trailing dot in hostname (valid DNS normalisation)', () => {
+        // 'web.portalhq.io.' is technically valid DNS — must still be trusted
+        expect((0, auth_1.isPortalHostedUrl)('https://web.portalhq.io./rpc/v1/eip155/1')).toBe(true);
+    });
+});
+// ─── buildDefaultRpcConfig ───────────────────────────────────────────────────
+describe('buildDefaultRpcConfig', () => {
+    it('returns exactly 13 entries', () => {
+        expect(Object.keys((0, defaults_1.buildDefaultRpcConfig)(defaults_1.DEFAULT_RPC_HOST))).toHaveLength(13);
+    });
+    it('includes all 11 expected EVM chains', () => {
+        const cfg = (0, defaults_1.buildDefaultRpcConfig)(defaults_1.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 = (0, defaults_1.buildDefaultRpcConfig)(defaults_1.DEFAULT_RPC_HOST);
+        expect(cfg).toHaveProperty('solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp');
+        expect(cfg).toHaveProperty('solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1');
+    });
+    it('does NOT include deprecated Polygon Mumbai (eip155:80001)', () => {
+        expect((0, defaults_1.buildDefaultRpcConfig)(defaults_1.DEFAULT_RPC_HOST)).not.toHaveProperty('eip155:80001');
+    });
+    it('every URL follows the template https://{rpcHost}/rpc/v1/{namespace}/{reference}', () => {
+        const cfg = (0, defaults_1.buildDefaultRpcConfig)(defaults_1.DEFAULT_RPC_HOST);
+        for (const [chainId, url] of Object.entries(cfg)) {
+            const [namespace, reference] = chainId.split(':');
+            expect(url).toBe(`https://${defaults_1.DEFAULT_RPC_HOST}/rpc/v1/${namespace}/${reference}`);
+        }
+    });
+    it('uses the production host by default', () => {
+        const cfg = (0, defaults_1.buildDefaultRpcConfig)();
+        expect(cfg['eip155:1']).toBe('https://web.portalhq.io/rpc/v1/eip155/1');
+    });
+    it('uses a custom rpcHost when provided', () => {
+        const cfg = (0, defaults_1.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 = (0, defaults_1.buildDefaultRpcConfig)('web.portalhq.dev');
+        for (const url of Object.values(cfg)) {
+            expect(url).not.toContain(defaults_1.DEFAULT_RPC_HOST);
+        }
+    });
+});
+// ─── Portal constructor — rpcConfig resolution ───────────────────────────────
+describe('Portal constructor — rpcConfig resolution', () => {
+    it('generates 13 default chains when rpcConfig is omitted', () => {
+        const portal = new _1.default({ apiKey: 'test-key' });
+        expect(Object.keys(portal.rpcConfig)).toHaveLength(13);
+    });
+    it('uses web.portalhq.io gateway URLs when rpcConfig is omitted', () => {
+        const portal = new _1.default({ 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 _1.default({ apiKey: 'test-key' });
+        const portalB = new _1.default({ 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 _1.default({ 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 _1.default({ apiKey: 'test-key', rpcConfig: custom });
+        expect(portal.rpcConfig['eip155:137']).toBeUndefined();
+    });
+    it('uses a custom gatewayHost in the generated default URLs', () => {
+        const portal = new _1.default({ 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 _1.default({ 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 _1.default({ 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 _1.default({ apiKey: 'test-key' });
+        expect(() => portal.getRpcUrl('eip155:99999')).toThrow();
+    });
+});

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPortalHostedUrl = void 0;
+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.
+ */
+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;
+    }
+}
+exports.isPortalHostedUrl = isPortalHostedUrl;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDefaultRpcConfig = exports.DEFAULT_RPC_HOST = void 0;
+/**
+ * Production Portal RPC gateway hostname.
+ * Staging equivalent: `web.portalhq.dev`.
+ * Used as the fallback when neither `gatewayHost` nor `host` is supplied.
+ */
+exports.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.
+ */
+function buildDefaultRpcConfig(rpcHost = exports.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`,
+    };
+}
+exports.buildDefaultRpcConfig = buildDefaultRpcConfig;

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

@@ -30,6 +30,7 @@ __exportStar(require("./yieldxyz"), exports);
 __exportStar(require("./zero-x"), exports);
 __exportStar(require("./lifi"), exports);
 __exportStar(require("./noah"), exports);
+__exportStar(require("./meld"), exports);
 __exportStar(require("./hypernative"), exports);
 __exportStar(require("./blockaid"), exports);
 // Account Abstraction types

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });