@dynamic-labs-sdk/evm 1.0.0 → 1.2.0

package/dist/index.esm.js

@@ -1,44 +1,14 @@
-import { a as version, i as name, n as createPublicClientFromNetworkData, r as mapNetworkDataToViemChain, t as createWalletClientForWalletAccount } from "./createWalletClientForWalletAccount-2HJ_yeO9.esm.js";
-import { i as isEvmWalletAccount, o as RpcError } from "./evmTransferAmount-D1PZCZks.esm.js";
-import "./createWalletProviderFromEIP1193Provider-BdZcBFWx.esm.js";
-import { t as addEIP6963Extension } from "./addEIP6963Extension-1jrwxkRl.esm.js";
-import { t as addWaasEvmExtension } from "./addWaasEvmExtension-CctMlyNt.esm.js";
+import { a as version, i as name, n as createPublicClientFromNetworkData, r as mapNetworkDataToViemChain, t as createWalletClientForWalletAccount } from "./createWalletClientForWalletAccount-CMD5kLVs.esm.js";
+import { i as isEvmWalletAccount, o as RpcError } from "./evmTransferAmount-C4vCjuss.esm.js";
+import "./createWalletProviderFromEIP1193Provider-ChSmbI-a.esm.js";
+import { t as addEIP6963Extension } from "./addEIP6963Extension-CTfW3lKP.esm.js";
+import { t as addWaasEvmExtension } from "./addWaasEvmExtension-DnfMMvBS.esm.js";
 import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
-import { assertDefined, createApiClient, getCore, getDefaultClient } from "@dynamic-labs-sdk/client/core";
-import { BaseError, FeeEstimationFailedError, InvalidParamError, SimulationFailedError, getActiveNetworkData, getDefaultClient as getDefaultClient$1, getNetworksData } from "@dynamic-labs-sdk/client";
+import { BaseError, FeeEstimationFailedError, InvalidParamError, SimulationFailedError, getActiveNetworkData, getDefaultClient, getNetworksData } from "@dynamic-labs-sdk/client";
+import { assertDefined, createApiClient, createRuntimeServiceAccessKey, getCore, getDefaultClient as getDefaultClient$1 } from "@dynamic-labs-sdk/client/core";
 import { formatEther } from "viem";
+import { signAuthorization } from "viem/actions";
 
-//#region src/addEvmExtension/addEvmExtension.ts
-/**
-* Adds the EVM extension to the Dynamic client.
-*
-* This is a convenience function that adds both the EIP-6963 extension
-* and the Dynamic WaaS EVM extension, enabling support for all EVM wallet types
-* including standard wallets and embedded wallets managed by Dynamic's infrastructure.
-*
-* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
-* @not-instrumented
-*/
-const addEvmExtension = (client = getDefaultClient()) => {
-	addEIP6963Extension(client);
-	addWaasEvmExtension(client);
-};
-
-//#endregion
-//#region src/errors/EvmGasSponsorshipNotEnabledError/EvmGasSponsorshipNotEnabledError.ts
-var EvmGasSponsorshipNotEnabledError = class extends BaseError {
-	constructor() {
-		super({
-			cause: null,
-			code: "evm_gas_sponsorship_not_enabled_error",
-			docsUrl: null,
-			name: "EvmGasSponsorshipNotEnabledError",
-			shortMessage: "EVM gas sponsorship is not enabled for this project"
-		});
-	}
-};
-
-//#endregion
 //#region src/errors/SponsorTransactionError/SponsorTransactionError.ts
 var SponsorTransactionError = class extends BaseError {
 	constructor(cause, details) {
@@ -53,197 +23,14 @@ var SponsorTransactionError = class extends BaseError {
 	}
 };
 
-//#endregion
-//#region src/gasless/getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.ts
-/**
-* Fetches the current relay state for a sponsored EVM transaction.
-*
-* Returns the lifecycle status, the on-chain transaction hash (when the relay
-* has broadcast it), and any terminal-failure error message. Use this as the
-* building block for custom polling flows; for the common "wait until done"
-* case prefer `waitForSponsoredTransaction`.
-*
-* @param params.requestId - The request ID returned when the transaction was relayed.
-* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
-* @returns The current status, optional transaction hash, and optional error message.
-* @throws {SponsorTransactionError} If the API call fails.
-* @not-instrumented
-*/
-const getEVMSponsoredTransactionStatus = async ({ requestId }, client = getDefaultClient()) => {
-	const core = getCore(client);
-	const apiClient = createApiClient({}, client);
-	let data;
-	try {
-		data = await apiClient.getEVMSponsoredTransactionStatus({
-			environmentId: core.environmentId,
-			requestId
-		});
-	} catch (error) {
-		throw new SponsorTransactionError(error instanceof Error ? error : null);
-	}
-	return {
-		errorMessage: data.errorMessage,
-		status: data.status,
-		transactionHash: data.transactionHash
-	};
-};
-
-//#endregion
-//#region src/gasless/isEvmGasSponsorshipEnabled/isEvmGasSponsorshipEnabled.ts
-/**
-* Checks if EVM gas sponsorship is enabled for the current project.
-*
-* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
-* @returns True if EVM gas sponsorship is enabled, false otherwise.
-* @not-instrumented
-*/
-const isEvmGasSponsorshipEnabled = (client = getDefaultClient$1()) => {
-	assertDefined(client.projectSettings, "Project settings are not defined");
-	return client.projectSettings.sdk.embeddedWallets?.evmGasSponsorshipEnabled ?? false;
-};
-
-//#endregion
-//#region src/isEvmNetworkProvider/isEvmNetworkProvider.ts
-/**
-* Type guard function to check if a network provider is an EVM network provider.
-*
-* @param networkProvider - The network provider to check.
-* @returns True if the network provider is an EVM network provider, false otherwise.
-* @not-instrumented
-*/
-const isEvmNetworkProvider = (networkProvider) => networkProvider.chain === "EVM";
-
-//#endregion
-//#region src/utils/calculateEvmTransactionFee/calculateEvmTransactionFee.ts
-/**
-* Calculates the estimated fee for an EVM transaction.
-*
-* This function estimates gas usage and calculates the total transaction fee
-* using either legacy gas pricing or EIP-1559 pricing. The fee is returned
-* in both native units (wei) and human-readable format (ETH).
-*
-* @param params.transaction - The transaction to estimate fees for.
-* @param params.networkData - Network configuration for RPC connection.
-* @param params.nativeTokenPriceUsd - Optional USD price of the native token for fee conversion.
-* @returns Fee data including gas estimates and human-readable amounts.
-* @throws {FeeEstimationFailedError} If gas estimation or fee retrieval fails.
-* @not-instrumented
-*/
-const calculateEvmTransactionFee = async ({ transaction, networkData, nativeTokenPriceUsd }) => {
-	try {
-		const publicClient = createPublicClientFromNetworkData({ networkData });
-		const gasEstimate = await publicClient.estimateGas({
-			account: transaction.from,
-			data: transaction.data,
-			to: transaction.to,
-			value: transaction.value
-		});
-		let maxFeePerGas;
-		let maxPriorityFeePerGas;
-		let gasPrice;
-		let nativeAmount;
-		try {
-			const feeData = await publicClient.estimateFeesPerGas();
-			maxFeePerGas = feeData.maxFeePerGas;
-			maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
-			nativeAmount = gasEstimate * maxFeePerGas;
-		} catch {
-			gasPrice = await publicClient.getGasPrice();
-			nativeAmount = gasEstimate * gasPrice;
-		}
-		const humanReadableAmount = formatEther(nativeAmount);
-		const usdAmount = nativeTokenPriceUsd ? (Number(humanReadableAmount) * nativeTokenPriceUsd).toFixed(2) : void 0;
-		return {
-			gasEstimate,
-			gasPrice,
-			humanReadableAmount,
-			maxFeePerGas,
-			maxPriorityFeePerGas,
-			nativeAmount,
-			usdAmount
-		};
-	} catch (error) {
-		throw new FeeEstimationFailedError({
-			cause: error instanceof Error ? error : void 0,
-			message: "Failed to estimate EVM transaction fee"
-		});
-	}
-};
-
-//#endregion
-//#region src/simulateEvmTransaction/simulateEvmTransaction.ts
-/**
-* Simulates an EVM transaction to preview its effects before execution.
-*
-* This function uses the Blockaid API to analyze the transaction and returns
-* information about asset transfers, security validation, and optionally fee estimates.
-* The simulation shows what will happen when the transaction is executed without
-* actually sending it to the blockchain.
-*
-* @param params.walletAccount - The EVM wallet account that will sign the transaction.
-* @param params.transaction - The transaction to simulate, including network ID.
-* @param params.includeFees - Whether to calculate transaction fees (default: false).
-* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
-* @returns Simulation result with asset diffs, security validation, and optional fee data.
-* @throws {InvalidParamError} If wallet account is not an EVM account or network ID is not configured.
-* @throws {SimulationFailedError} If the simulation API call fails.
-* @throws {FeeEstimationFailedError} If includeFees is true and fee calculation fails.
-* @not-instrumented
-*/
-const simulateEvmTransaction = async ({ walletAccount, transaction, includeFees = false }, client = getDefaultClient$1()) => {
-	if (!isEvmWalletAccount(walletAccount)) throw new InvalidParamError("Wallet account must be an EVM wallet account");
-	const networkData = getNetworksData(client).find((data) => data.networkId === transaction.networkId && data.chain === "EVM");
-	if (!networkData) throw new InvalidParamError(`Network with ID ${transaction.networkId} is not configured in project settings`);
-	try {
-		const core = getCore(client);
-		const apiClient = createApiClient({}, client);
-		const simulateEVMTransactionRequest = {
-			chainId: transaction.networkId,
-			data: transaction.data || "0x",
-			from: transaction.from,
-			to: transaction.to
-		};
-		if (transaction.value !== void 0) simulateEVMTransactionRequest.value = transaction.value.toString();
-		const response = await apiClient.simulateEVMTransaction({
-			environmentId: core.environmentId,
-			simulateEVMTransactionRequest
-		});
-		let feeData;
-		if (includeFees) feeData = await calculateEvmTransactionFee({
-			nativeTokenPriceUsd: response.priceData?.nativeTokenUsdPrice,
-			networkData,
-			transaction
-		});
-		return {
-			counterparties: response.counterparties,
-			feeData,
-			inAssets: response.inAssets || [],
-			outAssets: response.outAssets || [],
-			priceData: response.priceData,
-			showTotalFiat: response.showTotalFiat,
-			validation: response.validation ? {
-				description: response.validation.description,
-				reason: response.validation.reason,
-				result: response.validation.result
-			} : void 0
-		};
-	} catch (error) {
-		if (error instanceof FeeEstimationFailedError) throw error;
-		throw new SimulationFailedError({
-			cause: error instanceof Error ? error : void 0,
-			message: "Failed to simulate EVM transaction"
-		});
-	}
-};
-
 //#endregion
 //#region src/gasless/constants.ts
 /** The Fireblocks Universal Gasless Delegate (UGD) contract address used for EIP-7702 delegation. */
 const DELEGATION_CONTRACT_ADDRESS = "0x0000Fb7702036ff9f76044a501ac1aA74cbab16b";
-/** The ERC-7821 Forwarder contract address that relays calls to the delegated wallet. */
-const RELAYER_CONTRACT_ADDRESS = "0x0fb50CBAd1B82005628bc8aF0f7A6D81Bf74cDCe";
 /** Default sponsored transaction validity duration in seconds (10 minutes). */
 const DEFAULT_VALID_FOR_SECONDS = 600;
+/** EIP-7702 delegation code prefix used to identify delegated accounts. */
+const DELEGATION_CODE_PREFIX = "0xef0100";
 /** ERC-7579 batch call with opData and auth mode identifier. */
 const BATCH_CALL_OPDATA_AUTH_MODE = "0x0100000000007821000100000000000000000000000000000000000000000000";
 /** EIP-712 typed data types for UGD AuthorizedExecutions signing. */
@@ -344,6 +131,163 @@ const generateIntentNonce = async ({ walletAccount }, client) => {
 	return nonce;
 };
 
+//#endregion
+//#region src/gasless/getAvailableEvmGaslessRelayer/getAvailableEvmGaslessRelayer.ts
+/**
+* Fetches the relayer address to embed in the EIP-712 sponsored-transaction
+* intent for the given chain.
+*
+* The returned address is owned by the project's relay backend and is the
+* eventual `from` of the on-chain broadcast. It must be set as the `relayer`
+* field of the EIP-712 intent before signing — the on-chain delegate validates
+* the signature against this address.
+*
+* @param params.chainId - The EVM chain ID the sponsored transaction targets.
+* @param client - The Dynamic client instance.
+* @returns The relayer address to embed in the EIP-712 intent.
+* @throws {SponsorTransactionError} If the API call fails or returns no relayer address.
+* @not-instrumented
+*/
+const getAvailableEvmGaslessRelayer = async ({ chainId }, client) => {
+	const core = getCore(client);
+	const apiClient = createApiClient({}, client);
+	let data;
+	try {
+		data = await apiClient.getAvailableEVMGaslessRelayer({
+			chainId,
+			environmentId: core.environmentId
+		});
+	} catch (error) {
+		throw new SponsorTransactionError(error instanceof Error ? error : null);
+	}
+	if (!data.relayerAddress) throw new SponsorTransactionError();
+	return { relayerAddress: data.relayerAddress };
+};
+
+//#endregion
+//#region src/gasless/create7702DelegationRegistry/create7702DelegationRegistry.ts
+/**
+* Creates an in-memory registry that tracks which wallet+chain combinations
+* have active EIP-7702 delegation. Only active delegations are cached —
+* a missing entry means the status is unknown and should be checked via RPC.
+*
+* @not-instrumented
+*/
+const create7702DelegationRegistry = () => {
+	const delegated = /* @__PURE__ */ new Map();
+	const buildKey = ({ chainId, walletAddress }) => `${walletAddress.toLowerCase()}:${chainId}`;
+	return {
+		isDelegated: (params) => delegated.has(buildKey(params)),
+		markDelegated: (params) => {
+			delegated.set(buildKey(params), true);
+		}
+	};
+};
+
+//#endregion
+//#region src/gasless/get7702DelegationRegistry/get7702DelegationRegistry.ts
+/**
+* Returns the per-client EIP-7702 delegation registry, creating it on first access.
+*
+* @not-instrumented
+*/
+const get7702DelegationRegistry = createRuntimeServiceAccessKey("evm-7702-delegation-registry", () => create7702DelegationRegistry());
+
+//#endregion
+//#region src/gasless/is7702DelegationActive/is7702DelegationActive.ts
+/**
+* Checks whether EIP-7702 delegation to the Dynamic gasless contract is active
+* for the given wallet account on its current network.
+*
+* Results are cached per wallet+chain in an in-memory registry
+*
+* @param params.walletAccount - The EVM wallet account to check delegation status for.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns True if the wallet has an active delegation to the gasless contract.
+* @not-instrumented
+*/
+const is7702DelegationActive = async ({ walletAccount }, client = getDefaultClient$1()) => {
+	const { networkData } = await getActiveNetworkData({ walletAccount }, client);
+	assertDefined(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	const chainId = mapNetworkDataToViemChain(networkData).id;
+	const registry = get7702DelegationRegistry(client);
+	if (registry.isDelegated({
+		chainId,
+		walletAddress: walletAccount.address
+	})) return true;
+	const bytecode = await createPublicClientFromNetworkData({ networkData }).getCode({ address: walletAccount.address });
+	if (!bytecode) return false;
+	const expectedPrefix = DELEGATION_CODE_PREFIX + DELEGATION_CONTRACT_ADDRESS.slice(2).toLowerCase();
+	const isActive = bytecode.toLowerCase().startsWith(expectedPrefix);
+	if (isActive) registry.markDelegated({
+		chainId,
+		walletAddress: walletAccount.address
+	});
+	return isActive;
+};
+
+//#endregion
+//#region src/gasless/resolveChainId/resolveChainId.ts
+/**
+* Resolves a chain ID from either an explicit override or the wallet's active network.
+*
+* @param params.chainId - Explicit chain ID override.
+* @param params.walletAccount - The wallet account to resolve the chain from.
+* @param client - The Dynamic client instance.
+* @returns The resolved chain ID.
+* @not-instrumented
+*/
+const resolveChainId = async ({ chainId, walletAccount }, client) => {
+	if (chainId !== void 0) return chainId;
+	const { networkData } = await getActiveNetworkData({ walletAccount }, client);
+	assertDefined(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	return mapNetworkDataToViemChain(networkData).id;
+};
+
+//#endregion
+//#region src/gasless/sign7702Authorization/sign7702Authorization.ts
+/**
+* Signs an EIP-7702 authorization to delegate the wallet to the Dynamic
+* gasless delegation contract.
+*
+* The signed authorization can be included in a sponsored transaction to
+* activate the delegation on-chain. If no chainId is provided, the wallet's
+* active network chain ID is used.
+*
+* @param params.walletAccount - The EVM wallet account to sign the authorization for.
+* @param [params.chainId] - Override chain ID. Defaults to the wallet's active network.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The signed EIP-7702 authorization.
+* @not-instrumented
+*/
+const sign7702Authorization = async ({ walletAccount, chainId }, client = getDefaultClient$1()) => {
+	return signAuthorization(await createWalletClientForWalletAccount({ walletAccount }, client), {
+		chainId: await resolveChainId({
+			chainId,
+			walletAccount
+		}, client),
+		contractAddress: DELEGATION_CONTRACT_ADDRESS
+	});
+};
+
+//#endregion
+//#region src/gasless/resolveAuthorization/resolveAuthorization.ts
+/**
+* Resolves the EIP-7702 authorization for a sponsored transaction.
+*
+* Returns the provided authorization if given, auto-signs one if needed
+* and autoDelegate is true, or returns undefined if the wallet is already
+* delegated or autoDelegate is false.
+*
+* @not-instrumented
+*/
+const resolveAuthorization = async ({ authorization, autoDelegate, walletAccount }, client) => {
+	if (authorization) return authorization;
+	if (!autoDelegate) return;
+	if (await is7702DelegationActive({ walletAccount }, client)) return;
+	return sign7702Authorization({ walletAccount }, client);
+};
+
 //#endregion
 //#region src/gasless/toSerializedAuthorization/toSerializedAuthorization.ts
 /**
@@ -369,24 +313,34 @@ const toSerializedAuthorization = (auth) => {
 /**
 * Signs a sponsored transaction by creating an EIP-712 intent signature.
 *
-* If an authorization is provided, it is serialized and included in the
-* payload. Otherwise the intent is signed without any authorization
-* (caller manages delegation separately).
+* This function handles the complete signing flow:
+* - If an authorization is provided, it is included in the payload.
+* - If autoDelegate is true (default) and no authorization is provided,
+*   checks whether delegation is active and signs a 7702 authorization if needed.
+* - If autoDelegate is false and no authorization is provided, the intent
+*   is signed without any authorization (user manages delegation separately).
 *
 * @param params.walletAccount - The EVM wallet account to sign with.
 * @param params.calls - The batch of calls to execute.
-* @param [params.authorization] - Pre-signed EIP-7702 authorization to include.
+* @param [params.authorization] - Pre-signed EIP-7702 authorization. Takes priority over autoDelegate.
+* @param [params.autoDelegate] - Whether to auto-sign 7702 if not delegated. Defaults to true.
 * @param [params.validForSeconds] - How long the signed intent remains valid, in seconds. Defaults to 600 (10 minutes).
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 * @returns The signed sponsored transaction payload ready to be sent to the API.
 * @not-instrumented
 */
-const signSponsoredTransaction = async ({ walletAccount, calls, authorization, validForSeconds = DEFAULT_VALID_FOR_SECONDS }, client = getDefaultClient()) => {
+const signSponsoredTransaction = async ({ walletAccount, calls, authorization, autoDelegate = true, validForSeconds = DEFAULT_VALID_FOR_SECONDS }, client = getDefaultClient$1()) => {
 	const { networkData } = await getActiveNetworkData({ walletAccount }, client);
 	assertDefined(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	const resolvedAuthorization = await resolveAuthorization({
+		authorization,
+		autoDelegate,
+		walletAccount
+	}, client);
 	const nonce = await generateIntentNonce({ walletAccount }, client);
 	const deadline = BigInt(Math.floor(Date.now() / 1e3) + validForSeconds);
 	const chainId = mapNetworkDataToViemChain(networkData).id;
+	const { relayerAddress } = await getAvailableEvmGaslessRelayer({ chainId }, client);
 	const signature = await (await createWalletClientForWalletAccount({ walletAccount }, client)).signTypedData({
 		domain: {
 			chainId,
@@ -401,18 +355,18 @@ const signSponsoredTransaction = async ({ walletAccount, calls, authorization, v
 			deadline,
 			mode: BATCH_CALL_OPDATA_AUTH_MODE,
 			nonce,
-			relayer: RELAYER_CONTRACT_ADDRESS
+			relayer: relayerAddress
 		},
 		primaryType: "AuthorizedExecutions",
 		types: AUTHORIZED_EXECUTIONS_TYPES
 	});
 	return {
-		authorization: authorization ? toSerializedAuthorization(authorization) : void 0,
+		authorization: resolvedAuthorization ? toSerializedAuthorization(resolvedAuthorization) : void 0,
 		calls,
 		chainId,
 		deadline: deadline.toString(),
 		nonce: nonce.toString(),
-		relayer: RELAYER_CONTRACT_ADDRESS,
+		relayer: relayerAddress,
 		signature,
 		walletAddress: walletAccount.address
 	};
@@ -438,9 +392,10 @@ const isSignedTransactionParams = (params) => "signedTransaction" in params;
 * @throws {SponsorTransactionError} If the API call fails or returns an unexpected response.
 * @not-instrumented
 */
-const relaySponsoredTransaction = async (params, client = getDefaultClient()) => {
+const relaySponsoredTransaction = async (params, client = getDefaultClient$1()) => {
 	const signedTransaction = isSignedTransactionParams(params) ? params.signedTransaction : await signSponsoredTransaction({
 		authorization: params.authorization,
+		autoDelegate: params.autoDelegate,
 		calls: params.calls,
 		validForSeconds: params.validForSeconds ?? DEFAULT_VALID_FOR_SECONDS,
 		walletAccount: params.walletAccount
@@ -473,17 +428,49 @@ const relaySponsoredTransaction = async (params, client = getDefaultClient()) =>
 	return { requestId: data.requestId };
 };
 
+//#endregion
+//#region src/gasless/getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.ts
+/**
+* Fetches the current relay state for a sponsored EVM transaction.
+*
+* Returns the lifecycle status, the on-chain transaction hash (when the relay
+* has broadcast it), and any terminal-failure error message. Use this as the
+* building block for custom polling flows; for the common "wait until done"
+* case prefer `waitForSponsoredTransaction`.
+*
+* @param params.requestId - The request ID returned when the transaction was relayed.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The current status, optional transaction hash, and optional error message.
+* @throws {SponsorTransactionError} If the API call fails.
+* @not-instrumented
+*/
+const getEVMSponsoredTransactionStatus = async ({ requestId }, client = getDefaultClient$1()) => {
+	const core = getCore(client);
+	const apiClient = createApiClient({}, client);
+	let data;
+	try {
+		data = await apiClient.getEVMSponsoredTransactionStatus({
+			environmentId: core.environmentId,
+			requestId
+		});
+	} catch (error) {
+		throw new SponsorTransactionError(error instanceof Error ? error : null);
+	}
+	return {
+		errorMessage: data.errorMessage,
+		status: data.status,
+		transactionHash: data.transactionHash
+	};
+};
+
 //#endregion
 //#region src/gasless/waitForSponsoredTransaction/waitForSponsoredTransaction.ts
 const POLL_INTERVAL_MS = 2e3;
 const MAX_POLLING_ATTEMPTS = 6e4 / POLL_INTERVAL_MS;
+const TERMINAL_FAILURE_STATUSES = new Set(["failure"]);
 /**
-* Polls `getEVMSponsoredTransactionStatus` until the relay reaches a terminal
-* state and returns the on-chain transaction hash.
-*
-* Resolves on `CONFIRMED`. Throws `SponsorTransactionError` on terminal
-* failure statuses (`FAILED`, `CANCELED`, `EXPIRED`, `REJECTED`) or after a
-* 60s timeout.
+* Polls `getEVMSponsoredTransactionStatus` until the relay reports the
+* transaction has been included on-chain, then returns the transaction hash.
 *
 * @param params.requestId - The request ID returned when the transaction was relayed.
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
@@ -491,21 +478,11 @@ const MAX_POLLING_ATTEMPTS = 6e4 / POLL_INTERVAL_MS;
 * @throws {SponsorTransactionError} If the relay returns a terminal failure or polling times out.
 * @not-instrumented
 */
-const waitForSponsoredTransaction = async ({ requestId }, client = getDefaultClient$1()) => {
+const waitForSponsoredTransaction = async ({ requestId }, client = getDefaultClient()) => {
 	for (let attempt = 0; attempt < MAX_POLLING_ATTEMPTS; attempt++) {
 		const result = await getEVMSponsoredTransactionStatus({ requestId }, client);
-		switch (result.status) {
-			case "CONFIRMED":
-				if (!result.transactionHash) throw new SponsorTransactionError();
-				return { transactionHash: result.transactionHash };
-			case "CANCELED":
-			case "EXPIRED":
-			case "FAILED":
-			case "REJECTED": throw new SponsorTransactionError(null, result.errorMessage);
-			case "PENDING":
-			case "SENT":
-			case "SUBMITTED": break;
-		}
+		if (TERMINAL_FAILURE_STATUSES.has(result.status)) throw new SponsorTransactionError(null, result.errorMessage);
+		if (result.transactionHash) return { transactionHash: result.transactionHash };
 		if (attempt < MAX_POLLING_ATTEMPTS - 1) await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
 	}
 	throw new SponsorTransactionError(null, `Timed out waiting for sponsored transaction ${requestId}`);
@@ -514,12 +491,12 @@ const waitForSponsoredTransaction = async ({ requestId }, client = getDefaultCli
 //#endregion
 //#region src/gasless/sendSponsoredTransaction/sendSponsoredTransaction.ts
 /**
-* Sends a sponsored EVM transaction and waits for the on-chain transaction hash.
+* Sends a sponsored EVM transaction and waits for on-chain inclusion.
 *
 * Accepts either a pre-signed transaction or unsigned calls. When given
 * unsigned calls, signs the transaction first via signSponsoredTransaction.
-* Relays the transaction and polls until the relay reports a CONFIRMED
-* status, then returns the resulting transaction hash.
+* Relays the transaction and resolves as soon as the relay reports the
+* transaction has been included on-chain.
 *
 * @param params - Either { signedTransaction } or { walletAccount, calls, ... }.
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
@@ -527,15 +504,217 @@ const waitForSponsoredTransaction = async ({ requestId }, client = getDefaultCli
 * @throws {SponsorTransactionError} If the relay returns a terminal failure or polling times out.
 * @not-instrumented
 */
-const sendSponsoredTransaction = async (params, client = getDefaultClient$1()) => {
+const sendSponsoredTransaction = async (params, client = getDefaultClient()) => {
 	const { requestId } = await relaySponsoredTransaction(params, client);
 	return waitForSponsoredTransaction({ requestId }, client);
 };
 
+//#endregion
+//#region src/gasless/activate7702Delegation/activate7702Delegation.ts
+/**
+* Activates EIP-7702 delegation for a wallet by sending a sponsored
+* transaction that only contains the 7702 authorization.
+*
+* After activation, the wallet's delegation is persisted on-chain and
+* subsequent sponsored transactions no longer need to include the
+* authorization.
+*
+* @param params.walletAccount - The EVM wallet account to activate delegation for.
+* @param [params.authorization] - Pre-signed authorization. If omitted, signs one automatically.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns An object containing the on-chain transaction hash.
+* @throws {SponsorTransactionError} If the relay returns a terminal failure or polling times out.
+* @not-instrumented
+*/
+const activate7702Delegation = async ({ walletAccount, authorization }, client = getDefaultClient()) => sendSponsoredTransaction({
+	authorization,
+	calls: [],
+	walletAccount
+}, client);
+
+//#endregion
+//#region src/addEvmExtension/addEvmExtension.ts
+/**
+* Adds the EVM extension to the Dynamic client.
+*
+* This is a convenience function that adds both the EIP-6963 extension
+* and the Dynamic WaaS EVM extension, enabling support for all EVM wallet types
+* including standard wallets and embedded wallets managed by Dynamic's infrastructure.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @not-instrumented
+*/
+const addEvmExtension = (client = getDefaultClient$1()) => {
+	addEIP6963Extension(client);
+	addWaasEvmExtension(client);
+};
+
+//#endregion
+//#region src/errors/EvmGasSponsorshipNotEnabledError/EvmGasSponsorshipNotEnabledError.ts
+var EvmGasSponsorshipNotEnabledError = class extends BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "evm_gas_sponsorship_not_enabled_error",
+			docsUrl: null,
+			name: "EvmGasSponsorshipNotEnabledError",
+			shortMessage: "EVM gas sponsorship is not enabled for this project"
+		});
+	}
+};
+
+//#endregion
+//#region src/gasless/isEvmGasSponsorshipEnabled/isEvmGasSponsorshipEnabled.ts
+/**
+* Checks if EVM gas sponsorship is enabled for the current project.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns True if EVM gas sponsorship is enabled, false otherwise.
+* @not-instrumented
+*/
+const isEvmGasSponsorshipEnabled = (client = getDefaultClient()) => {
+	assertDefined(client.projectSettings, "Project settings are not defined");
+	return client.projectSettings.sdk.embeddedWallets?.evmGasSponsorshipEnabled ?? false;
+};
+
+//#endregion
+//#region src/isEvmNetworkProvider/isEvmNetworkProvider.ts
+/**
+* Type guard function to check if a network provider is an EVM network provider.
+*
+* @param networkProvider - The network provider to check.
+* @returns True if the network provider is an EVM network provider, false otherwise.
+* @not-instrumented
+*/
+const isEvmNetworkProvider = (networkProvider) => networkProvider.chain === "EVM";
+
+//#endregion
+//#region src/utils/calculateEvmTransactionFee/calculateEvmTransactionFee.ts
+/**
+* Calculates the estimated fee for an EVM transaction.
+*
+* This function estimates gas usage and calculates the total transaction fee
+* using either legacy gas pricing or EIP-1559 pricing. The fee is returned
+* in both native units (wei) and human-readable format (ETH).
+*
+* @param params.transaction - The transaction to estimate fees for.
+* @param params.networkData - Network configuration for RPC connection.
+* @param params.nativeTokenPriceUsd - Optional USD price of the native token for fee conversion.
+* @returns Fee data including gas estimates and human-readable amounts.
+* @throws {FeeEstimationFailedError} If gas estimation or fee retrieval fails.
+* @not-instrumented
+*/
+const calculateEvmTransactionFee = async ({ transaction, networkData, nativeTokenPriceUsd }) => {
+	try {
+		const publicClient = createPublicClientFromNetworkData({ networkData });
+		const gasEstimate = await publicClient.estimateGas({
+			account: transaction.from,
+			data: transaction.data,
+			to: transaction.to,
+			value: transaction.value
+		});
+		let maxFeePerGas;
+		let maxPriorityFeePerGas;
+		let gasPrice;
+		let nativeAmount;
+		try {
+			const feeData = await publicClient.estimateFeesPerGas();
+			maxFeePerGas = feeData.maxFeePerGas;
+			maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
+			nativeAmount = gasEstimate * maxFeePerGas;
+		} catch {
+			gasPrice = await publicClient.getGasPrice();
+			nativeAmount = gasEstimate * gasPrice;
+		}
+		const humanReadableAmount = formatEther(nativeAmount);
+		const usdAmount = nativeTokenPriceUsd ? (Number(humanReadableAmount) * nativeTokenPriceUsd).toFixed(2) : void 0;
+		return {
+			gasEstimate,
+			gasPrice,
+			humanReadableAmount,
+			maxFeePerGas,
+			maxPriorityFeePerGas,
+			nativeAmount,
+			usdAmount
+		};
+	} catch (error) {
+		throw new FeeEstimationFailedError({
+			cause: error instanceof Error ? error : void 0,
+			message: "Failed to estimate EVM transaction fee"
+		});
+	}
+};
+
+//#endregion
+//#region src/simulateEvmTransaction/simulateEvmTransaction.ts
+/**
+* Simulates an EVM transaction to preview its effects before execution.
+*
+* This function uses the Blockaid API to analyze the transaction and returns
+* information about asset transfers, security validation, and optionally fee estimates.
+* The simulation shows what will happen when the transaction is executed without
+* actually sending it to the blockchain.
+*
+* @param params.walletAccount - The EVM wallet account that will sign the transaction.
+* @param params.transaction - The transaction to simulate, including network ID.
+* @param params.includeFees - Whether to calculate transaction fees (default: false).
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns Simulation result with asset diffs, security validation, and optional fee data.
+* @throws {InvalidParamError} If wallet account is not an EVM account or network ID is not configured.
+* @throws {SimulationFailedError} If the simulation API call fails.
+* @throws {FeeEstimationFailedError} If includeFees is true and fee calculation fails.
+* @not-instrumented
+*/
+const simulateEvmTransaction = async ({ walletAccount, transaction, includeFees = false }, client = getDefaultClient()) => {
+	if (!isEvmWalletAccount(walletAccount)) throw new InvalidParamError("Wallet account must be an EVM wallet account");
+	const networkData = getNetworksData(client).find((data) => data.networkId === transaction.networkId && data.chain === "EVM");
+	if (!networkData) throw new InvalidParamError(`Network with ID ${transaction.networkId} is not configured in project settings`);
+	try {
+		const core = getCore(client);
+		const apiClient = createApiClient({}, client);
+		const simulateEVMTransactionRequest = {
+			chainId: transaction.networkId,
+			data: transaction.data || "0x",
+			from: transaction.from,
+			to: transaction.to
+		};
+		if (transaction.value !== void 0) simulateEVMTransactionRequest.value = transaction.value.toString();
+		const response = await apiClient.simulateEVMTransaction({
+			environmentId: core.environmentId,
+			simulateEVMTransactionRequest
+		});
+		let feeData;
+		if (includeFees) feeData = await calculateEvmTransactionFee({
+			nativeTokenPriceUsd: response.priceData?.nativeTokenUsdPrice,
+			networkData,
+			transaction
+		});
+		return {
+			counterparties: response.counterparties,
+			feeData,
+			inAssets: response.inAssets || [],
+			outAssets: response.outAssets || [],
+			priceData: response.priceData,
+			showTotalFiat: response.showTotalFiat,
+			validation: response.validation ? {
+				description: response.validation.description,
+				reason: response.validation.reason,
+				result: response.validation.result
+			} : void 0
+		};
+	} catch (error) {
+		if (error instanceof FeeEstimationFailedError) throw error;
+		throw new SimulationFailedError({
+			cause: error instanceof Error ? error : void 0,
+			message: "Failed to simulate EVM transaction"
+		});
+	}
+};
+
 //#endregion
 //#region src/exports/index.ts
 assertPackageVersion(name, version);
 
 //#endregion
-export { EvmGasSponsorshipNotEnabledError, RpcError, SponsorTransactionError, addEvmExtension, calculateEvmTransactionFee, getEVMSponsoredTransactionStatus, isEvmGasSponsorshipEnabled, isEvmNetworkProvider, isEvmWalletAccount, relaySponsoredTransaction, sendSponsoredTransaction, signSponsoredTransaction, simulateEvmTransaction, waitForSponsoredTransaction };
+export { EvmGasSponsorshipNotEnabledError, RpcError, SponsorTransactionError, activate7702Delegation, addEvmExtension, calculateEvmTransactionFee, getEVMSponsoredTransactionStatus, is7702DelegationActive, isEvmGasSponsorshipEnabled, isEvmNetworkProvider, isEvmWalletAccount, relaySponsoredTransaction, sendSponsoredTransaction, sign7702Authorization, signSponsoredTransaction, simulateEvmTransaction, waitForSponsoredTransaction };
 //# sourceMappingURL=index.esm.js.map