@rabby-wallet/rabby-bridge 0.0.13-alpha.0 → 0.0.13

package/dist/providers/relay.js

@@ -1,185 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
-import { _TypedDataEncoder } from '@ethersproject/hash';
-import { getBridgeRouter } from '../list.js';
-import { decodeBridgeCalldataResult } from '../calldata/index.js';
-import { asBigint, asString, decodeCall } from '../calldata/abi.js';
-import { address, array, bytes, chain, object, text, tokenAddress, transaction, uint } from './data.js';
-// Relay settlement-sdk 0.0.152 ORDER_EIP712_TYPES. EVM addresses are 20-byte
-// dynamic bytes, not bytes32. Unknown order versions/VMs fail closed.
-// Deadlines remain part of the order hash; they are not checked against the clock.
-const ORDER_TYPES = {
-    Order: [
-        { name: 'version', type: 'string' }, { name: 'solverChainId', type: 'string' },
-        { name: 'solver', type: 'address' }, { name: 'salt', type: 'uint256' },
-        { name: 'inputs', type: 'Input[]' }, { name: 'output', type: 'Output' }, { name: 'fees', type: 'Fee[]' },
-    ],
-    Input: [{ name: 'payment', type: 'InputPayment' }, { name: 'refunds', type: 'InputRefund[]' }],
-    InputPayment: [
-        { name: 'chainId', type: 'string' }, { name: 'currency', type: 'bytes' },
-        { name: 'amount', type: 'uint256' }, { name: 'weight', type: 'uint256' },
-    ],
-    InputRefund: [
-        { name: 'chainId', type: 'string' }, { name: 'recipient', type: 'bytes' }, { name: 'currency', type: 'bytes' },
-        { name: 'minimumAmount', type: 'uint256' }, { name: 'deadline', type: 'uint32' }, { name: 'extraData', type: 'bytes' },
-    ],
-    Output: [
-        { name: 'chainId', type: 'string' }, { name: 'payments', type: 'OutputPayment[]' },
-        { name: 'deadline', type: 'uint32' }, { name: 'calls', type: 'bytes[]' }, { name: 'extraData', type: 'bytes' },
-    ],
-    OutputPayment: [
-        { name: 'recipient', type: 'bytes' }, { name: 'currency', type: 'bytes' },
-        { name: 'minimumAmount', type: 'uint256' }, { name: 'expectedAmount', type: 'uint256' },
-    ],
-    Fee: [
-        { name: 'recipientChainId', type: 'string' }, { name: 'recipient', type: 'bytes' },
-        { name: 'currencyChainId', type: 'string' }, { name: 'currency', type: 'bytes' }, { name: 'amount', type: 'uint256' },
-    ],
-};
-// Pin protocol identifiers independently of the service's mutable /chains response.
-const RELAY_EVM_CHAIN_IDS = {
-    ethereum: 1n, optimism: 10n, cronos: 25n, bnb: 56n, gnosis: 100n, unichain: 130n,
-    polygon: 137n, monad: 143n, sonic: 146n, manta: 169n, xlayer: 196n, boba: 288n,
-    zksync: 324n, shape: 360n, worldchain: 480n, flow: 747n, stable: 988n, hyperevm: 999n,
-    metis: 1088n, soneium: 1868n, ronin: 2020n, abstract: 2741n, morph: 2818n,
-    tempo: 4217n, megaeth: 4326n, robinhood: 4663n, mantle: 5000n, somnia: 5031n,
-    arc: 5042n, base: 8453n, plasma: 9745n, apechain: 33139n, mode: 34443n,
-    mythos: 42018n, arbitrum: 42161n, celo: 42220n, avalanche: 43114n, zircuit: 48900n,
-    ink: 57073n, linea: 59144n, bob: 60808n, berachain: 80094n, doma: 97477n,
-    plume: 98866n, scroll: 534352n, gensyn: 685689n, katana: 747474n,
-    ethereal: 5064014n, zora: 7777777n,
-};
-export const relayChains = (value) => {
-    const result = [];
-    for (const raw of array(object(value).chains)) {
-        const c = object(raw);
-        if (c.vmType !== 'evm' || !c.protocol)
-            continue;
-        const v2 = object(c.protocol).v2;
-        if (!v2)
-            continue;
-        const protocol = object(v2);
-        const entry = { evmId: uint(c.id), protocolId: text(protocol.chainId), depository: address(protocol.depository) };
-        if (!Object.prototype.hasOwnProperty.call(RELAY_EVM_CHAIN_IDS, entry.protocolId))
-            continue;
-        if (RELAY_EVM_CHAIN_IDS[entry.protocolId] !== entry.evmId)
-            throw new BridgeError(BRIDGE_ERRORS.RELAY_PROTOCOL_CHAIN_MISMATCH);
-        if (result.some((other) => other.evmId === entry.evmId || other.protocolId === entry.protocolId))
-            throw new BridgeError(BRIDGE_ERRORS.AMBIGUOUS_RELAY_CHAIN);
-        result.push(entry);
-    }
-    return result;
-};
-export const relayOrder = (raw, metadata) => {
-    const o = object(raw);
-    if (o.version !== 'v1')
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_ORDER_VERSION);
-    const evm = (id) => {
-        const protocolId = text(id);
-        if (!metadata.some((c) => c.protocolId === protocolId))
-            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_VM);
-        return protocolId;
-    };
-    const output = object(o.output);
-    return {
-        version: o.version,
-        solverChainId: evm(o.solverChainId), solver: address(o.solver), salt: uint(o.salt).toString(),
-        inputs: array(o.inputs).map((rawInput) => {
-            const input = object(rawInput), payment = object(input.payment);
-            return {
-                payment: { chainId: evm(payment.chainId), currency: address(payment.currency), amount: uint(payment.amount).toString(), weight: uint(payment.weight).toString() },
-                refunds: array(input.refunds).map((rawRefund) => {
-                    const r = object(rawRefund);
-                    return { chainId: evm(r.chainId), recipient: address(r.recipient), currency: address(r.currency),
-                        minimumAmount: uint(r.minimumAmount).toString(), deadline: uint(r.deadline, 32).toString(), extraData: bytes(r.extraData) };
-                }),
-            };
-        }),
-        output: {
-            chainId: evm(output.chainId), deadline: uint(output.deadline, 32).toString(), extraData: bytes(output.extraData),
-            calls: array(output.calls).map((call) => bytes(call)),
-            payments: array(output.payments).map((rawPayment) => {
-                const p = object(rawPayment);
-                return { recipient: address(p.recipient), currency: address(p.currency),
-                    minimumAmount: uint(p.minimumAmount).toString(), expectedAmount: uint(p.expectedAmount).toString() };
-            }),
-        },
-        fees: array(o.fees).map((rawFee) => {
-            const f = object(rawFee);
-            return { recipientChainId: evm(f.recipientChainId), recipient: address(f.recipient),
-                currencyChainId: evm(f.currencyChainId), currency: address(f.currency), amount: uint(f.amount).toString() };
-        }),
-    };
-};
-export const readRelayQuote = (raw, params, metadata) => {
-    const q = object(raw);
-    const protocol = object(object(q.protocol).v2);
-    const order = relayOrder(protocol.orderData, metadata);
-    const orderId = _TypedDataEncoder.hashStruct('Order', ORDER_TYPES, order).toLowerCase();
-    if (orderId !== bytes(protocol.orderId, 32))
-        throw new BridgeError(BRIDGE_ERRORS.RELAY_ORDER_HASH_MISMATCH);
-    if (order.inputs.length !== 1 || order.output.payments.length !== 1 || order.output.calls.length !== 0)
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_ORDER_SHAPE);
-    const source = metadata.find((c) => c.evmId === chain(params.fromChainId));
-    const destination = metadata.find((c) => c.evmId === chain(params.toChainId));
-    if (!source || !destination || order.inputs[0].payment.chainId !== source.protocolId || order.output.chainId !== destination.protocolId)
-        throw new BridgeError(BRIDGE_ERRORS.RELAY_ORDER_CHAIN_MISMATCH);
-    if (source.depository !== getBridgeRouter('relay', params.fromChainId)?.toLowerCase()) {
-        throw new BridgeError(BRIDGE_ERRORS.RELAY_CANONICAL_DEPOSITORY_MISMATCH);
-    }
-    for (const refund of order.inputs[0].refunds) {
-        if (refund.recipient !== address(params.userAddress))
-            throw new BridgeError(BRIDGE_ERRORS.RELAY_REFUND_RECIPIENT_MISMATCH);
-    }
-    const steps = array(q.steps).map(object);
-    const deposits = steps.filter((step) => step.id === 'deposit');
-    if (deposits.length !== 1 || deposits[0].kind !== 'transaction' || deposits[0].depositAddress)
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_DEPOSIT);
-    const items = array(deposits[0].items);
-    if (items.length !== 1)
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_DEPOSIT_COUNT);
-    const tx = transaction(object(items[0]).data, params);
-    const decodedResult = decodeBridgeCalldataResult('relay', tx);
-    if (!decodedResult.ok)
-        throw new BridgeError(BRIDGE_ERRORS.INVALID_CALLDATA, {}, decodedResult.errors);
-    const decoded = decodedResult.parsed;
-    if (!decoded || !['depositNative', 'depositErc20'].includes(decoded.method))
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_DEPOSIT_METHOD);
-    const payment = order.inputs[0].payment;
-    const paymentDetails = object(protocol.paymentDetails);
-    if (tx.to.toLowerCase() !== source.depository || address(paymentDetails.depository) !== source.depository ||
-        paymentDetails.chainId !== source.protocolId || address(paymentDetails.currency) !== payment.currency ||
-        uint(paymentDetails.amount) !== uint(payment.amount) ||
-        decoded.orderId !== orderId || decoded.depositor !== address(params.userAddress) ||
-        decoded.sourceToken !== payment.currency || decoded.sourceAmount !== uint(payment.amount))
-        throw new BridgeError(BRIDGE_ERRORS.RELAY_SOURCE_PAYMENT_MISMATCH);
-    if (payment.currency !== tokenAddress(params.fromTokenId, params.fromChainId) ||
-        uint(tx.value) !== (payment.currency === '0x0000000000000000000000000000000000000000' ? uint(payment.amount) : 0n))
-        throw new BridgeError(BRIDGE_ERRORS.RELAY_SOURCE_VALUE_MISMATCH);
-    // Approval steps are never executed from the response. Verify their semantics,
-    // then expose only the spender so the host can build its own approval.
-    const approvals = steps.filter((step) => step.id === 'approve');
-    if (approvals.length > 1)
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_APPROVAL_COUNT);
-    for (const step of steps) {
-        if (!['approve', 'deposit'].includes(text(step.id)))
-            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_STEP);
-    }
-    for (const step of approvals) {
-        const approvalsItems = array(step.items);
-        if (step.kind !== 'transaction' || approvalsItems.length !== 1)
-            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_APPROVAL);
-        const approval = transaction(object(approvalsItems[0]).data, params);
-        if (!approval.data.startsWith('0x095ea7b3') || approval.to !== payment.currency || uint(approval.value) !== 0n)
-            throw new BridgeError(BRIDGE_ERRORS.RELAY_APPROVAL_MISMATCH);
-        const args = decodeCall([{ name: 'spender', kind: 'address' }, { name: 'amount', kind: 'uint' }], approval.data);
-        if (asString(args.spender) !== source.depository || asBigint(args.amount) !== uint(payment.amount))
-            throw new BridgeError(BRIDGE_ERRORS.RELAY_APPROVAL_MISMATCH);
-    }
-    const output = order.output.payments[0];
-    return {
-        tx, orderId, requestId: bytes(deposits[0].requestId, 32), expectedAmount: uint(output.expectedAmount),
-        approveAddress: payment.currency === '0x0000000000000000000000000000000000000000' ? '' : source.depository,
-        parsed: { ...decoded, destinationChainId: destination.evmId, outputToken: output.currency,
-            minOutputAmount: uint(output.minimumAmount), receiver: output.recipient, unresolvedFields: [] },
-    };
-};

package/dist/providers/request.d.ts

@@ -1,23 +0,0 @@
-import type { BridgeServiceRequest, BridgeVerificationProvider } from './types.js';
-export declare const BRIDGE_PROVIDER_ORIGINS: Readonly<{
-    relay: "https://api.relay.link";
-    socket: "https://public-backend.socket.tech";
-    socketDedicated: "https://dedicated-backend.socket.tech";
-    layerswap: "https://api.layerswap.io";
-}>;
-export declare const requestProvider: (request: BridgeServiceRequest, timeoutMs: number, provider: BridgeVerificationProvider, path: string, body?: unknown, socketApi?: "public" | "dedicated") => Promise<unknown>;
-/** Minimal Fetch surface supported by browser service workers and React Native. */
-export type BridgeFetch = (url: string, init: {
-    method: string;
-    headers: Record<string, string>;
-    body?: string;
-    signal: AbortSignal;
-    credentials: 'omit';
-    redirect: 'error';
-}) => Promise<{
-    ok: boolean;
-    status?: number;
-    json(): Promise<unknown>;
-}>;
-/** No global fetch dependency: each host supplies its own transport explicitly. */
-export declare const createBridgeFetchRequest: (fetch: BridgeFetch) => BridgeServiceRequest;

package/dist/providers/request.js

@@ -1,69 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError, asBridgeError } from '../errors/index.js';
-import { InvalidBridgeProviderError } from './errors.js';
-export const BRIDGE_PROVIDER_ORIGINS = Object.freeze({
-    relay: 'https://api.relay.link',
-    socket: 'https://public-backend.socket.tech',
-    socketDedicated: 'https://dedicated-backend.socket.tech',
-    layerswap: 'https://api.layerswap.io',
-});
-export const requestProvider = async (request, timeoutMs, provider, path, body, socketApi = 'public') => {
-    // Paths are constructed by the SDK. Never follow endpoints in a quote response.
-    const allowed = provider === 'relay'
-        ? path === '/chains' || path === '/quote/v2'
-        : provider === 'socket' ? path.startsWith('/v3/swap/quote?')
-            : /^\/api\/v2\/explorer\/0x[0-9a-f]{40}\?page=[1-9][0-9]*$/i.test(path);
-    if (!allowed)
-        throw new InvalidBridgeProviderError(provider, BRIDGE_ERRORS.UNSUPPORTED_SERVICE_PATH);
-    const requestKind = provider === 'relay' ? (path === '/chains' ? 'relay_chains' : 'relay_quote')
-        : provider === 'socket' ? 'socket_quote' : 'layerswap_orders';
-    const controller = new AbortController();
-    let timer;
-    try {
-        return await Promise.race([
-            Promise.resolve().then(() => request({
-                url: (provider === 'socket' && socketApi === 'dedicated'
-                    ? BRIDGE_PROVIDER_ORIGINS.socketDedicated : BRIDGE_PROVIDER_ORIGINS[provider]) + path,
-                method: body === undefined ? 'GET' : 'POST',
-                body,
-                timeoutMs,
-                signal: controller.signal,
-            })),
-            new Promise((_, reject) => {
-                timer = setTimeout(() => {
-                    reject(new InvalidBridgeProviderError(provider, BRIDGE_ERRORS.REQUEST_TIMED_OUT));
-                    controller.abort();
-                }, timeoutMs);
-            }),
-        ]);
-    }
-    catch (error) {
-        const failure = asBridgeError(error, BRIDGE_ERRORS.SERVICE_REQUEST_FAILED, { requestKind });
-        if (failure instanceof InvalidBridgeProviderError)
-            throw failure;
-        // Do not propagate provider bodies, wallet addresses or request details as errors.
-        throw new InvalidBridgeProviderError(provider, failure);
-    }
-    finally {
-        if (timer !== undefined)
-            clearTimeout(timer);
-    }
-};
-/** No global fetch dependency: each host supplies its own transport explicitly. */
-export const createBridgeFetchRequest = (fetch) => async (request) => {
-    const response = await fetch(request.url, {
-        method: request.method,
-        headers: { Accept: 'application/json', ...(request.body === undefined ? {} : { 'Content-Type': 'application/json' }) },
-        body: request.body === undefined ? undefined : JSON.stringify(request.body),
-        signal: request.signal,
-        credentials: 'omit',
-        redirect: 'error',
-    });
-    if (!response.ok)
-        throw new BridgeError(BRIDGE_ERRORS.PROVIDER_HTTP_ERROR, { httpStatus: response.status });
-    try {
-        return await response.json();
-    }
-    catch {
-        throw new BridgeError(BRIDGE_ERRORS.PROVIDER_RESPONSE_IS_NOT_VALID_JSON);
-    }
-};

package/dist/providers/socket.d.ts

@@ -1,5 +0,0 @@
-import type { BridgeQuoteListParams } from '../quote.js';
-import type { ProviderQuoteData } from './relay.js';
-export declare const SOCKET_PROVIDER_ROUTES: readonly string[];
-export declare const socketBridgeId: (value: unknown) => string;
-export declare const readSocketQuote: (raw: unknown, rawRoute: unknown, params: BridgeQuoteListParams) => ProviderQuoteData;

package/dist/providers/socket.js

@@ -1,57 +0,0 @@
-import { sourceAmountMatches } from '../calldata/expect.js';
-import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
-import { decodeBridgeCalldataResult } from '../calldata/index.js';
-import { address, bytes, chain, object, text, tokenAddress, transaction, uint } from './data.js';
-export const SOCKET_PROVIDER_ROUTES = Object.freeze(['rfq-vault-executor', 'cctp-v2', 'cctp-v2-slow']);
-export const socketBridgeId = (value) => text(value).trim().toLowerCase().replace(/ /g, '-').replace(/^circle-cctp/, 'cctp');
-export const readSocketQuote = (raw, rawRoute, params) => {
-    const result = object(raw), route = object(rawRoute);
-    const details = object(object(route.routeDetails).bridgeDetails);
-    const bridgeId = socketBridgeId(object(details.protocol).name);
-    if (!SOCKET_PROVIDER_ROUTES.includes(bridgeId) || route.userOp !== 'tx')
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_SERVICE_ROUTE);
-    const input = object(result.input), inputToken = object(input.token);
-    const output = object(route.output), outputToken = object(output.token);
-    if (uint(result.originChainId) !== chain(params.fromChainId) || uint(result.destinationChainId) !== chain(params.toChainId) ||
-        uint(inputToken.chainId) !== chain(params.fromChainId) || uint(outputToken.chainId) !== chain(params.toChainId) ||
-        address(result.userAddress) !== address(params.userAddress) || address(result.receiverAddress) !== address(params.userAddress) ||
-        tokenAddress(text(inputToken.address), params.fromChainId) !== tokenAddress(params.fromTokenId, params.fromChainId) ||
-        !sourceAmountMatches(uint(input.amount), uint(params.fromTokenRawAmount)))
-        throw new BridgeError(BRIDGE_ERRORS.SOCKET_QUOTE_INPUT_MISMATCH);
-    const txData = object(route.txData);
-    if (txData.kind !== 'evm_tx')
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_TRANSACTION);
-    const tx = transaction(txData.object, params);
-    const decodedResult = decodeBridgeCalldataResult('socket', tx);
-    if (!decodedResult.ok)
-        throw new BridgeError(BRIDGE_ERRORS.INVALID_CALLDATA, {}, decodedResult.errors);
-    const parsed = decodedResult.parsed;
-    const quoteId = bytes(route.quoteId, 32);
-    if (!parsed || parsed.quoteId !== quoteId || parsed.depositor !== address(params.userAddress) ||
-        parsed.sourceAmount !== uint(input.amount))
-        throw new BridgeError(BRIDGE_ERRORS.SOCKET_SOURCE_QUOTE_MISMATCH);
-    if (bridgeId === 'rfq-vault-executor') {
-        if (parsed.protocolMethod !== 'receiveERC20' || parsed.orderId !== quoteId)
-            throw new BridgeError(BRIDGE_ERRORS.SOCKET_RFQ_ORDER_MISMATCH);
-    }
-    else if (parsed.protocolMethod !== 'depositForBurn' || parsed.bridgeReceiver !== '0x424a31a57f7c63918ecaa2fac38016a8af5a6ec2') {
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_CCTP_RECEIVER);
-    }
-    const destinationToken = tokenAddress(text(outputToken.address), params.toChainId);
-    if (parsed.outputToken && tokenAddress(parsed.outputToken, params.toChainId) !== destinationToken)
-        throw new BridgeError(BRIDGE_ERRORS.SOCKET_BRIDGE_OUTPUT_MISMATCH);
-    if (parsed.destinationChainId !== undefined && parsed.destinationChainId !== chain(params.toChainId))
-        throw new BridgeError(BRIDGE_ERRORS.SOCKET_BRIDGE_CHAIN_MISMATCH);
-    const approval = route.approval ? object(route.approval) : undefined;
-    const native = tokenAddress(params.fromTokenId, params.fromChainId) === '0x0000000000000000000000000000000000000000';
-    if (!native && (!approval || address(approval.tokenAddress) !== tokenAddress(params.fromTokenId, params.fromChainId) ||
-        address(approval.userAddress) !== address(params.userAddress) || uint(approval.amount) !== uint(input.amount)))
-        throw new BridgeError(BRIDGE_ERRORS.SOCKET_APPROVAL_MISMATCH);
-    return {
-        tx, orderId: quoteId, requestId: quoteId,
-        approveAddress: native ? '' : address(approval.spenderAddress),
-        expectedAmount: uint(output.amount),
-        parsed: { ...parsed, destinationChainId: chain(params.toChainId), outputToken: destinationToken,
-            minOutputAmount: uint(output.minAmountOut), receiver: address(result.receiverAddress), unresolvedFields: [] },
-    };
-};

package/dist/providers/types.d.ts

@@ -1,36 +0,0 @@
-import type { ParsedBridgeCall } from '../calldata/types.js';
-import type { BridgeBuildTxParams, BridgeQuoteListItem, BridgeQuoteListParams, BridgeTx } from '../quote.js';
-export type DirectBridgeProvider = 'relay' | 'socket';
-export type BridgeVerificationProvider = DirectBridgeProvider | 'layerswap';
-/** Returns the decoded JSON body. Do not route this through Rabby's OpenAPI client. */
-export type BridgeServiceRequest = (request: {
-    url: string;
-    method: 'GET' | 'POST';
-    body?: unknown;
-    timeoutMs: number;
-    signal: AbortSignal;
-}) => Promise<unknown>;
-export type BridgeProviderVerification = {
-    provider: BridgeVerificationProvider;
-    /** LayerSwap associates calldata requestId with a directly fetched provider record. */
-    binding: 'order-hash' | 'provider-transaction' | 'provider-record';
-    parsed: ParsedBridgeCall;
-};
-export interface BridgeProviderClient {
-    getQuotes(provider: DirectBridgeProvider, params: BridgeQuoteListParams): Promise<BridgeQuoteListItem[]>;
-    buildTx(provider: DirectBridgeProvider, params: BridgeBuildTxParams): Promise<BridgeTx>;
-    /** Recheck the final transaction after any wallet preparation and before signing. */
-    verifyTx(provider: BridgeVerificationProvider, params: BridgeBuildTxParams, tx: BridgeTx): BridgeProviderVerification;
-    /** Fetch the same LayerSwap order by recipient + calldata requestId before signing. */
-    verifyLayerSwapTx(params: BridgeBuildTxParams, tx: BridgeTx): Promise<BridgeProviderVerification>;
-    /** Detect clear() during asynchronous host/backend work outside the client. */
-    captureContext(): () => void;
-    /** Call on lock/account changes; also invalidates pending quote responses. */
-    clear(): void;
-}
-export type BridgeProviderClientOptions = {
-    request: BridgeServiceRequest;
-    timeoutMs?: number;
-    /** Dedicated access needs provider-issued client credentials in the host transport. */
-    socketApi?: 'public' | 'dedicated';
-};

package/dist/providers/types.js

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