viem 2.56.8 → 2.57.0

package/_esm/tempo/internal/relay/cache.js

@@ -0,0 +1,72 @@
+import { withTimeout } from '../../../utils/promise/withTimeout.js';
+// Scope in-flight work to one request so Workers never share request-owned I/O.
+const flights = new WeakMap();
+const prefix = 'viem:relay:cache:';
+export function scoped(store) {
+    if (!store)
+        return undefined;
+    return {
+        getItem: (key) => store.getItem(key),
+        setItem: (key, value) => store.setItem(key, value),
+        removeItem: (key) => store.removeItem(key),
+    };
+}
+export async function memoize(fetch, options) {
+    const { store, ttl } = options;
+    const key = `${prefix}${options.key}`;
+    let active = true;
+    const timeoutError = new Error('Relay cache operation timed out.');
+    return withTimeout(async () => {
+        const raw = await store.getItem(key);
+        if (!active)
+            throw timeoutError;
+        if (raw) {
+            try {
+                const entry = JSON.parse(raw, (_key, item) => {
+                    if (typeof item !== 'string' || !item.startsWith(prefix))
+                        return item;
+                    if (item.startsWith(`${prefix}string:`))
+                        return item.slice(`${prefix}string:`.length);
+                    if (item.startsWith(`${prefix}bigint:`))
+                        return BigInt(item.slice(`${prefix}bigint:`.length));
+                    throw new TypeError('Invalid relay cache value.');
+                });
+                if (entry.expiresAt > Date.now())
+                    return entry.value;
+            }
+            catch {
+                // Refresh malformed or older entries.
+            }
+        }
+        let pending = flights.get(store);
+        if (!pending) {
+            pending = new Map();
+            flights.set(store, pending);
+        }
+        const existing = pending.get(key);
+        if (existing)
+            return existing;
+        const result = (async () => {
+            const value = await fetch();
+            if (!active)
+                throw timeoutError;
+            if (value !== undefined)
+                await store.setItem(key, JSON.stringify({ value, expiresAt: Date.now() + ttl }, (_key, item) => {
+                    if (typeof item === 'bigint')
+                        return `${prefix}bigint:${item}`;
+                    if (typeof item === 'string' && item.startsWith(prefix))
+                        return `${prefix}string:${item}`;
+                    return item;
+                }));
+            return value;
+        })().finally(() => pending.delete(key));
+        pending.set(key, result);
+        return result;
+    }, {
+        timeout: 30_000,
+        errorInstance: timeoutError,
+    }).finally(() => {
+        active = false;
+    });
+}
+//# sourceMappingURL=cache.js.map

package/_esm/tempo/internal/relay/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../../tempo/internal/relay/cache.ts"],"names":[],"mappings":"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"}

package/_esm/tempo/internal/relay/deadline.js

@@ -0,0 +1,34 @@
+import { RpcResponse } from 'ox';
+/** Bounds the complete fill, including callbacks that do not observe abort signals. */
+export async function run(handler, request, options, config) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', abort, { once: true });
+    if (options.signal?.aborted)
+        abort();
+    const timeout = setTimeout(() => controller.abort(new RpcResponse.LimitExceededError({
+        message: 'Relay fill exceeded its deadline.',
+    })), config.timeout ?? 10_000);
+    const signal = controller.signal;
+    let rejectAbort;
+    const aborted = new Promise((_, reject) => {
+        rejectAbort = reject;
+    });
+    const onAbort = () => rejectAbort(signal.reason);
+    signal.addEventListener('abort', onAbort, { once: true });
+    try {
+        signal.throwIfAborted();
+        return await Promise.race([
+            handler(request, { ...options, signal }),
+            aborted,
+        ]);
+    }
+    finally {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener('abort', abort);
+        signal.removeEventListener('abort', onAbort);
+        // Prevent timed-out hooks from dispatching additional I/O after the response completes.
+        controller.abort();
+    }
+}
+//# sourceMappingURL=deadline.js.map

package/_esm/tempo/internal/relay/deadline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.js","sourceRoot":"","sources":["../../../../tempo/internal/relay/deadline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,IAAI,CAAA;AAGhC,uFAAuF;AACvF,MAAM,CAAC,KAAK,UAAU,GAAG,CACvB,OAAoC,EACpC,OAAoC,EACpC,OAA2C,EAC3C,MAAmC;IAEnC,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAA;IACxC,MAAM,KAAK,GAAG,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5D,OAAO,CAAC,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAA;IAChE,IAAI,OAAO,CAAC,MAAM,EAAE,OAAO;QAAE,KAAK,EAAE,CAAA;IACpC,MAAM,OAAO,GAAG,UAAU,CACxB,GAAG,EAAE,CACH,UAAU,CAAC,KAAK,CACd,IAAI,WAAW,CAAC,kBAAkB,CAAC;QACjC,OAAO,EAAE,mCAAmC;KAC7C,CAAC,CACH,EACH,MAAM,CAAC,OAAO,IAAI,MAAM,CACzB,CAAA;IACD,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAA;IAEhC,IAAI,WAAuC,CAAA;IAC3C,MAAM,OAAO,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;QAC/C,WAAW,GAAG,MAAM,CAAA;IACtB,CAAC,CAAC,CAAA;IACF,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAChD,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAA;IACzD,IAAI,CAAC;QACH,MAAM,CAAC,cAAc,EAAE,CAAA;QACvB,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC;YACxB,OAAO,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,CAAC;YACxC,OAAO;SACR,CAAC,CAAA;IACJ,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,OAAO,CAAC,CAAA;QACrB,OAAO,CAAC,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACnD,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAC5C,wFAAwF;QACxF,UAAU,CAAC,KAAK,EAAE,CAAA;IACpB,CAAC;AACH,CAAC"}

package/_esm/tempo/internal/relay/error.js

@@ -0,0 +1,101 @@
+import { Hex } from 'ox';
+import { zeroAddress } from '../../../constants/address.js';
+import { formatUnits } from '../../../utils/unit/formatUnits.js';
+import * as ExecutionError from '../../ExecutionError.js';
+import { resolveTokenMetadata } from './feeToken.js';
+import { simulateAndParseDiffs } from './simulate.js';
+import * as Utils from './utils.js';
+import { extractCalls, resolveVirtualAddresses } from './virtualAddress.js';
+/** Distinguishes execution reverts from transport and plugin failures. */
+export function isExecutionError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const seen = new Set();
+    const pending = [error];
+    while (pending.length) {
+        const current = pending.pop();
+        if (!current || typeof current !== 'object' || seen.has(current))
+            continue;
+        seen.add(current);
+        const candidate = current;
+        if (candidate.code === 3 ||
+            candidate.name === 'UpstreamRevertError' ||
+            candidate.name === 'ExecutionRevertedError' ||
+            candidate.name === 'ContractFunctionRevertedError' ||
+            [candidate.message, candidate.details].some((message) => typeof message === 'string' && /^execution reverted\b/i.test(message)))
+            return true;
+        pending.push(candidate.cause, candidate.error);
+    }
+    return false;
+}
+export async function formatError(error, parameters, client, simulateStore) {
+    const revert = ExecutionError.from(error);
+    const stub = {
+        from: parameters.from,
+        to: parameters.to ?? null,
+        gas: '0x0',
+        nonce: '0x0',
+        value: '0x0',
+        maxFeePerGas: '0x0',
+        maxPriorityFeePerGas: '0x0',
+    };
+    if (revert.errorName === 'InsufficientBalance' && revert.args?.length === 3) {
+        const [available, required, token] = revert.args;
+        const normalized = Utils.normalizeFillTransactionRequest(parameters);
+        // Simulate from zero address for optimistic balance diffs.
+        const optimisticCalls = normalized ? extractCalls(normalized) : undefined;
+        const [{ balanceDiffs, tokenMetadata }, virtualAddresses] = optimisticCalls
+            ? await Promise.all([
+                simulateAndParseDiffs(client, {
+                    account: zeroAddress,
+                    calls: optimisticCalls,
+                    store: simulateStore,
+                }),
+                resolveVirtualAddresses(client, { calls: optimisticCalls }).catch(() => undefined),
+            ])
+            : [{ balanceDiffs: undefined, tokenMetadata: undefined }, undefined];
+        // Re-key balance diffs from zero address to the real sender.
+        const senderDiffs = parameters.from && balanceDiffs
+            ? { [parameters.from]: balanceDiffs[zeroAddress] ?? [] }
+            : balanceDiffs;
+        const metadata = await resolveTokenMetadata(client, {
+            token,
+            tokenMetadata,
+            store: simulateStore,
+        }).catch(() => undefined);
+        const deficit = required - available;
+        return {
+            tx: stub,
+            capabilities: {
+                balanceDiffs: senderDiffs,
+                error: ExecutionError.serialize(revert),
+                insufficientFunds: metadata
+                    ? {
+                        amount: Hex.fromNumber(deficit),
+                        decimals: metadata.decimals,
+                        formatted: formatUnits(deficit, metadata.decimals),
+                        token,
+                        symbol: metadata.symbol,
+                    }
+                    : undefined,
+                sponsored: false,
+                ...(virtualAddresses ? { virtualAddresses } : {}),
+            },
+        };
+    }
+    const normalized = Utils.normalizeFillTransactionRequest(parameters);
+    const virtualAddresses = normalized
+        ? await resolveVirtualAddresses(client, {
+            calls: extractCalls(normalized),
+        }).catch(() => undefined)
+        : undefined;
+    return {
+        tx: stub,
+        capabilities: {
+            error: ExecutionError.serialize(revert),
+            sponsored: false,
+            ...(virtualAddresses ? { virtualAddresses } : {}),
+        },
+    };
+}
+//# sourceMappingURL=error.js.map

package/_esm/tempo/internal/relay/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../../tempo/internal/relay/error.ts"],"names":[],"mappings":"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"}

package/_esm/tempo/internal/relay/feePayer.js

@@ -0,0 +1,442 @@
+import { Hash, RpcResponse, Signature } from 'ox';
+import { TxEnvelopeTempo } from 'ox/tempo';
+import { createClient } from '../../../clients/createClient.js';
+import { http } from '../../../clients/transports/http.js';
+import * as Transaction from '../../Transaction.js';
+import * as Request from './request.js';
+import * as Utils from './utils.js';
+export function create(options) {
+    // Bind signing permission to the middleware invocation and its validated payload.
+    const authorized = new WeakMap();
+    const allowedFeePayers = new Set(options.allowedFeePayers?.map((url) => ExternalFeePayerUrl.normalize(url, {
+        allowUnsafe: options.internal_allowUnsafeUrls,
+    })));
+    return {
+        async handleRequest(context, next) {
+            const { request } = context;
+            if (![
+                'eth_fillTransaction',
+                'eth_signRawTransaction',
+                'eth_sendRawTransaction',
+                'eth_sendRawTransactionSync',
+            ].includes(request.method))
+                return next();
+            const { client, getClient, options: requestOptions } = context;
+            const chainId = requestOptions.chainId;
+            const getTokens = (id) => context.resolveTokens(id);
+            const record = (details) => {
+                if (details && requestOptions.response)
+                    requestOptions.response.sponsorship_details = details;
+            };
+            if (request.method !== 'eth_fillTransaction') {
+                if (!options.account) {
+                    if (request.method === 'eth_signRawTransaction')
+                        throw new RpcResponse.MethodNotFoundError({
+                            message: 'eth_signRawTransaction requires a fee payer to be configured on the relay. Add `Relay.feePayer({ account })` to enable transaction sponsorship.',
+                        });
+                    return next();
+                }
+                const serialized = request.params?.[0];
+                if (typeof serialized !== 'string' ||
+                    !requestsRawSponsorship(serialized))
+                    return next();
+                const result = await handleRawTransaction({
+                    ...options,
+                    account: options.account,
+                    getClient,
+                    getFeeToken: async (id) => (await getTokens(id))[0],
+                    method: request.method,
+                    request,
+                });
+                record(result.sponsorshipDetails);
+                return result.result;
+            }
+            const parameters = request.params[0];
+            const { feePayer: _, ...normalized } = Utils.normalizeFillTransactionRequest(parameters);
+            const external = typeof parameters.feePayer === 'string'
+                ? ExternalFeePayerUrl.normalize(parameters.feePayer, {
+                    allowUnsafe: options.internal_allowUnsafeUrls ?? false,
+                })
+                : undefined;
+            if (external && !allowedFeePayers.has(external))
+                throw new RpcResponse.InvalidParamsError({
+                    message: 'External fee payer URL is not allowed.',
+                });
+            const wantsSponsorship = (!!options.account || !!external) && parameters.feePayer !== false;
+            if (options.account && !external)
+                delete normalized.feePayerSignature;
+            const base = { ...normalized, chainId };
+            if (!wantsSponsorship)
+                return Request.fill(client, base);
+            const token = options.feeToken ??
+                parameters.feeToken ??
+                (!options.validate || external
+                    ? (await getTokens(chainId))[0]
+                    : undefined);
+            const transaction = {
+                ...base,
+                feePayer: true,
+                ...(token ? { feeToken: token } : {}),
+            };
+            const prepared = isPreparedTransaction(transaction);
+            const fillClient = external
+                ? createClient({
+                    chain: client.chain,
+                    transport: http(external, {
+                        fetchOptions: { redirect: 'error' },
+                        retryCount: 0,
+                    }),
+                })
+                : client;
+            const result = prepared && !external
+                ? { tx: transaction }
+                : await Request.fill(fillClient, transaction, external ? { ...requestOptions, retryCount: 0 } : requestOptions);
+            const filled = Utils.normalizeTempoTransaction(result.tx);
+            // Reserve intrinsic gas for larger signatures before validating and signing the candidate.
+            if ((!prepared || parameters.feePayer !== true) &&
+                filled.gas &&
+                !filled.feePayerSignature)
+                filled.gas += 20000n;
+            if (token && (!external || filled.feeToken == null))
+                Object.assign(filled, { feeToken: token });
+            const sponsored = external ||
+                !options.validate ||
+                (await shouldSponsor({
+                    sender: parameters.from,
+                    transaction: filled,
+                    validate: options.validate,
+                }));
+            if (!sponsored)
+                return Request.fill(client, { ...base, feePayer: false });
+            const defer = typeof normalized.multisigSimulation === 'object' &&
+                normalized.multisigSimulation !== null;
+            const sponsor = sponsored
+                ? external
+                    ? (result.capabilities?.sponsor ?? result.sponsor)
+                    : options.account
+                        ? getSponsor({ ...options, account: options.account })
+                        : undefined
+                : undefined;
+            if (options.account && !external && !defer) {
+                delete filled.signature;
+                if (!filled.from)
+                    filled.from = parameters.from;
+                authorized.set(context, TxEnvelopeTempo.getFeePayerSignPayload(TxEnvelopeTempo.from(filled), { sender: filled.from }));
+            }
+            return {
+                ...result,
+                ...(sponsor ? { sponsor } : {}),
+                tx: Utils.formatTempoTransaction(filled),
+                capabilities: {
+                    ...result.capabilities,
+                    sponsored: external
+                        ? (result.capabilities?.sponsored ?? !!sponsor)
+                        : !!sponsor,
+                    ...(sponsor ? { sponsor } : {}),
+                },
+            };
+        },
+        async signTransaction(result, context) {
+            const approved = authorized.get(context);
+            authorized.delete(context);
+            const parameters = context.request.params[0];
+            if (!approved ||
+                !options.account ||
+                typeof parameters.feePayer === 'string' ||
+                parameters.feePayer === false ||
+                !result.capabilities?.sponsored ||
+                (typeof parameters.multisigSimulation === 'object' &&
+                    parameters.multisigSimulation !== null))
+                return undefined;
+            const transaction = Utils.normalizeTempoTransaction(result.tx);
+            const payload = TxEnvelopeTempo.getFeePayerSignPayload(TxEnvelopeTempo.from(transaction), { sender: (transaction.from ?? parameters.from) });
+            if (payload !== approved)
+                throw new RpcResponse.InvalidParamsError({
+                    message: 'Sponsored transaction changed after validation.',
+                });
+            const signed = await sign({
+                account: options.account,
+                onSponsored: options.onSponsored,
+                sender: parameters.from,
+                transaction,
+                signal: context.options.signal,
+            });
+            if (signed.sponsorshipDetails && context.options.response)
+                context.options.response.sponsorship_details = signed.sponsorshipDetails;
+            const tx = Utils.formatTempoTransaction(signed.transaction);
+            return tx.feePayerSignature;
+        },
+    };
+}
+/** Refusal messages keyed by named validation reason. */
+const refusalMessages = {
+    billing_past_due: 'Billing past due.',
+    billing_required: 'Billing required.',
+    fee_token_unsupported: 'Fee token unsupported.',
+    spend_limit_exceeded: 'Spend limit exceeded.',
+    tx_fee_limit_exceeded: 'Transaction fee limit exceeded.',
+};
+/** Returns sponsor metadata for `eth_fillTransaction` responses. */
+// biome-ignore lint/correctness/noUnusedVariables: declaration merge
+function getSponsor(options) {
+    const { account, name, url } = options;
+    return {
+        address: account.address,
+        ...(name ? { name } : {}),
+        ...(url ? { url } : {}),
+    };
+}
+/** Returns whether the fee payer approves a filled transaction. */
+// biome-ignore lint/correctness/noUnusedVariables: declaration merge
+async function shouldSponsor(options) {
+    const { sender, transaction, validate } = options;
+    if (!validate)
+        return true;
+    // Named refusal reasons collapse to false: fills fall back to an
+    // unsponsored fill instead of surfacing the reason.
+    const verdict = await validate({
+        ...transaction,
+        from: sender,
+    });
+    return verdict === true;
+}
+/** Returns whether a raw Tempo transaction is explicitly requesting sponsorship. */
+function requestsRawSponsorship(serialized) {
+    if (!Utils.isSerializedTempoTransaction(serialized))
+        return false;
+    const transaction = Transaction.deserialize(serialized);
+    return ('feePayerSignature' in transaction && transaction.feePayerSignature === null);
+}
+/** Returns `true` when a fill request already has the fields needed for sponsorship signing. */
+function isPreparedTransaction(value) {
+    return (typeof value.from === 'string' &&
+        typeof Utils.resolveChainId(value.chainId) === 'number' &&
+        typeof value.gas !== 'undefined' &&
+        typeof value.nonce !== 'undefined' &&
+        (typeof value.maxFeePerGas !== 'undefined' ||
+            typeof value.gasPrice !== 'undefined'));
+}
+/** Signs a filled transaction as the fee payer. */
+export async function sign(options) {
+    const { account, transaction, sender } = options;
+    const from = transaction.from ?? sender;
+    const { signature: _, ...withoutSenderSig } = transaction;
+    const prepared = { ...withoutSenderSig, from };
+    if (!prepared.from)
+        throw new RpcResponse.InvalidParamsError({
+            message: 'Transaction sender must be provided before fee payer signing.',
+        });
+    if (!account.sign)
+        throw new Error('Fee payer account cannot sign transactions.');
+    const chainId = Utils.resolveChainId(transaction.chainId);
+    if (chainId === undefined)
+        throw new RpcResponse.InvalidParamsError({
+            message: 'Transaction chainId must be provided before fee payer signing.',
+        });
+    const envelope = TxEnvelopeTempo.from(prepared);
+    const signPayload = TxEnvelopeTempo.getFeePayerSignPayload(envelope, {
+        sender: prepared.from,
+    });
+    options.signal?.throwIfAborted();
+    const feePayerSignature = Signature.from(await account.sign({ hash: signPayload }));
+    options.signal?.throwIfAborted();
+    // Record the commitment before releasing the signature, since the signed fill can be broadcast through another endpoint.
+    const feeToken = transaction.feeToken;
+    const sponsorshipDetails = await options.onSponsored?.({
+        chainId,
+        ...(feeToken ? { feeToken } : {}),
+        method: 'eth_fillTransaction',
+        sender: prepared.from,
+        signPayload,
+        transaction: TxEnvelopeTempo.serialize(envelope, { feePayerSignature }),
+    });
+    return {
+        ...(sponsorshipDetails ? { sponsorshipDetails } : {}),
+        transaction: { ...prepared, feePayerSignature },
+    };
+}
+/** Handles `eth_signRawTransaction` and broadcast methods for sponsored Tempo transactions. */
+// biome-ignore lint/correctness/noUnusedVariables: declaration merge
+async function handleRawTransaction(options) {
+    const { account, feeToken: sponsorFeeToken, getClient, method, request, validate, } = options;
+    const serialized = request.params?.[0];
+    if (!Utils.isSerializedTempoTransaction(serialized))
+        throw new RpcResponse.InvalidParamsError({
+            message: 'Only Tempo (0x76/0x78) transactions are supported.',
+        });
+    const transaction = Transaction.deserialize(serialized);
+    // Prefer sender recovered from raw envelope; multisig finalize path supplies fallback sender.
+    const sender = transaction.from ?? options.sender;
+    // Sponsorship only applies after sender has signed original transaction.
+    if (!transaction.signature || !sender)
+        throw new RpcResponse.InvalidParamsError({
+            message: 'Transaction must be signed by the sender before fee payer signing.',
+        });
+    if (!account.sign)
+        throw new Error('Fee payer account cannot sign transactions.');
+    const client = getClient(transaction.chainId);
+    const feeToken_chain = client.chain?.feeToken;
+    const feeToken = transaction.feeToken ??
+        sponsorFeeToken ??
+        (await options.getFeeToken?.(transaction.chainId)) ??
+        feeToken_chain;
+    const transaction_sponsored = feeToken
+        ? { ...transaction, feeToken }
+        : transaction;
+    if (validate) {
+        const verdict = await validate(transaction_sponsored);
+        if (verdict !== true)
+            throw new RpcResponse.InvalidParamsError(verdict === false
+                ? { message: 'Sponsorship rejected.' }
+                : { data: { code: verdict }, message: refusalMessages[verdict] });
+    }
+    const envelope = TxEnvelopeTempo.from(transaction_sponsored);
+    const signPayload = TxEnvelopeTempo.getFeePayerSignPayload(envelope, {
+        sender,
+    });
+    const feePayerSignature = Signature.from(await account.sign({ hash: signPayload }));
+    const serializedTransaction = TxEnvelopeTempo.serialize(envelope, {
+        feePayerSignature,
+        signature: transaction.signature,
+    });
+    // Awaited before any broadcast so a recording failure refuses sponsorship;
+    // no sponsored transaction ever reaches the chain unrecorded.
+    const sponsorshipDetails = await options.onSponsored?.({
+        chainId: transaction.chainId,
+        ...(feeToken ? { feeToken } : {}),
+        method,
+        sender,
+        signPayload,
+        transaction: serializedTransaction,
+        transactionHash: Hash.keccak256(serializedTransaction),
+    });
+    // Raw-sign requests stop after fee-payer signature is added; send methods broadcast it.
+    const result = method === 'eth_signRawTransaction'
+        ? serializedTransaction
+        : await client.request({
+            method: method,
+            params: [
+                serializedTransaction,
+                ...(request.params?.slice(1) ?? []),
+            ],
+        });
+    return { result, ...(sponsorshipDetails ? { sponsorshipDetails } : {}) };
+}
+export var ExternalFeePayerUrl;
+(function (ExternalFeePayerUrl) {
+    /** Normalizes external fee-payer relay URLs before forwarding fill payloads. */
+    function normalize(value, options = {}) {
+        let url;
+        try {
+            url = new URL(value);
+        }
+        catch {
+            throw new RpcResponse.InvalidParamsError({
+                message: 'Invalid fee payer URL.',
+            });
+        }
+        const allowUnsafe = options.allowUnsafe === true;
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            throw new RpcResponse.InvalidParamsError({
+                message: 'Invalid fee payer URL protocol.',
+            });
+        if (!allowUnsafe && url.protocol !== 'https:')
+            throw new RpcResponse.InvalidParamsError({
+                message: 'Invalid fee payer URL protocol.',
+            });
+        if (!allowUnsafe && isUnsafeHostname(url.hostname))
+            throw new RpcResponse.InvalidParamsError({
+                message: 'Invalid fee payer URL host.',
+            });
+        url.username = '';
+        url.password = '';
+        url.hash = '';
+        return url.href;
+    }
+    ExternalFeePayerUrl.normalize = normalize;
+    function isUnsafeHostname(hostname) {
+        const host = normalizeHostname(hostname);
+        if (host === 'localhost' || host.endsWith('.localhost'))
+            return true;
+        const ipv4 = parseIpv4(host);
+        if (ipv4)
+            return isUnsafeIpv4(ipv4);
+        if (!host.includes(':'))
+            return false;
+        const ipv6 = parseIpv6(host);
+        if (!ipv6)
+            return true;
+        return isUnsafeIpv6(ipv6);
+    }
+    function normalizeHostname(hostname) {
+        return hostname
+            .toLowerCase()
+            .replace(/^\[|\]$/g, '')
+            .split('%')[0];
+    }
+    function parseIpv4(value) {
+        const parts = value.split('.');
+        if (parts.length !== 4 || parts.some((part) => !/^\d+$/.test(part)))
+            return undefined;
+        const numbers = parts.map((part) => Number(part));
+        if (numbers.some((part) => !Number.isInteger(part) || part < 0 || part > 255))
+            return undefined;
+        return numbers;
+    }
+    function isUnsafeIpv4(parts) {
+        const [a, b] = parts;
+        if (a === 0 || a === 10 || a === 127)
+            return true;
+        if (a === 100 && b >= 64 && b <= 127)
+            return true;
+        if (a === 169 && b === 254)
+            return true;
+        if (a === 172 && b >= 16 && b <= 31)
+            return true;
+        if (a === 192 && b === 168)
+            return true;
+        return a >= 224;
+    }
+    function parseIpv6(value) {
+        const halves = value.split('::');
+        if (halves.length > 2)
+            return undefined;
+        const left = halves[0] ? halves[0].split(':') : [];
+        const right = halves[1] ? halves[1].split(':') : [];
+        const missing = halves.length === 2 ? 8 - left.length - right.length : 0;
+        if (missing < 0)
+            return undefined;
+        const parts = [...left, ...Array(missing).fill('0'), ...right];
+        if (parts.length !== 8)
+            return undefined;
+        const numbers = parts.map((part) => /^[\da-f]{1,4}$/i.test(part) ? Number.parseInt(part, 16) : NaN);
+        if (numbers.some((part) => !Number.isInteger(part) || part < 0 || part > 0xffff))
+            return undefined;
+        return numbers;
+    }
+    function isUnsafeIpv6(parts) {
+        const [a] = parts;
+        if (parts.every((part) => part === 0))
+            return true;
+        if (parts.slice(0, 7).every((part) => part === 0) && parts[7] === 1)
+            return true;
+        if ((a & 0xfe00) === 0xfc00)
+            return true;
+        if ((a & 0xffc0) === 0xfe80)
+            return true;
+        if ((a & 0xffc0) === 0xfec0)
+            return true;
+        if ((a & 0xff00) === 0xff00)
+            return true;
+        const ipv4 = ipv4FromIpv6(parts);
+        return ipv4 ? isUnsafeIpv4(ipv4) : false;
+    }
+    function ipv4FromIpv6(parts) {
+        const mapped = parts.slice(0, 5).every((part) => part === 0) && parts[5] === 0xffff;
+        const compatible = parts.slice(0, 6).every((part) => part === 0);
+        if (!mapped && !compatible)
+            return undefined;
+        return [parts[6] >> 8, parts[6] & 0xff, parts[7] >> 8, parts[7] & 0xff];
+    }
+})(ExternalFeePayerUrl || (ExternalFeePayerUrl = {}));
+//# sourceMappingURL=feePayer.js.map