@dynamic-labs-sdk/evm 1.4.0 → 1.6.0

package/dist/evmTransferAmount-BQDSXSva.native.esm.js

@@ -0,0 +1,875 @@
+import { i as mapNetworkDataToViemChain, n as isEvmWalletProviderWithCustomViemClient, r as createPublicClientFromNetworkData, t as createWalletClientForWalletAccount } from "./createWalletClientForWalletAccount-CuakQYYA.native.esm.js";
+import { BaseError, InvalidParamError, getActiveNetworkData, getDefaultClient } from "@dynamic-labs-sdk/client";
+import { assertDefined, createApiClient, createBaseNetworkProvider, createRuntimeServiceAccessKey, getCore, getDefaultClient as getDefaultClient$1, getNetworkProviderBuilderRegistry, getWalletProviderFromWalletAccount } from "@dynamic-labs-sdk/client/core";
+import { encodeFunctionData, erc20Abi, parseEther, parseUnits } from "viem";
+import { signAuthorization } from "viem/actions";
+
+//#region src/errors/SponsorTransactionError/SponsorTransactionError.ts
+var SponsorTransactionError = class extends BaseError {
+	constructor(cause, details) {
+		super({
+			cause: cause ?? null,
+			code: "sponsor_transaction_error",
+			details,
+			docsUrl: null,
+			name: "SponsorTransactionError",
+			shortMessage: "Failed to sponsor 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";
+/** 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. */
+const AUTHORIZED_EXECUTIONS_TYPES = {
+	AuthorizedExecutions: [
+		{
+			name: "calls",
+			type: "Execution[]"
+		},
+		{
+			name: "deadline",
+			type: "uint256"
+		},
+		{
+			name: "mode",
+			type: "bytes32"
+		},
+		{
+			name: "nonce",
+			type: "uint256"
+		},
+		{
+			name: "relayer",
+			type: "address"
+		}
+	],
+	Execution: [
+		{
+			name: "target",
+			type: "address"
+		},
+		{
+			name: "value",
+			type: "uint256"
+		},
+		{
+			name: "data",
+			type: "bytes"
+		}
+	]
+};
+/** Minimal ABI for the UGD contract's nonce validation function. */
+const UGD_ABI = [{
+	inputs: [{
+		name: "nonce",
+		type: "uint256"
+	}],
+	name: "isNonceUsed",
+	outputs: [{
+		name: "",
+		type: "bool"
+	}],
+	stateMutability: "view",
+	type: "function"
+}];
+
+//#endregion
+//#region src/gasless/generateRandomNonce/generateRandomNonce.ts
+/**
+* Generates a cryptographically random 256-bit nonce.
+*
+* @returns A random bigint nonce.
+* @not-instrumented
+*/
+const generateRandomNonce = () => {
+	const bytes = new Uint8Array(32);
+	crypto.getRandomValues(bytes);
+	return bytes.reduce((acc, byte) => acc << 8n | BigInt(byte), 0n);
+};
+
+//#endregion
+//#region src/gasless/generateIntentNonce/generateIntentNonce.ts
+/**
+* Generates a random bitmap nonce for UGD AuthorizedExecutions signing.
+*
+* Uses crypto.getRandomValues() for 256-bit randomness. Validates against
+* the on-chain isNonceUsed check as a safety measure, although collision
+* is essentially impossible with 256-bit random values.
+*
+* @param params.walletAccount - The wallet account whose delegation contract is checked.
+* @param [client] - The Dynamic client instance.
+* @returns A unique bigint nonce for the EIP-712 intent.
+* @not-instrumented
+*/
+const generateIntentNonce = async ({ walletAccount }, client) => {
+	const nonce = generateRandomNonce();
+	const { networkData } = await getActiveNetworkData({ walletAccount }, client);
+	assertDefined(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	const publicClient = createPublicClientFromNetworkData({ networkData });
+	try {
+		if (await publicClient.readContract({
+			abi: UGD_ABI,
+			address: walletAccount.address,
+			args: [nonce],
+			functionName: "isNonceUsed"
+		})) return generateRandomNonce();
+	} catch {}
+	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
+/**
+* Converts a viem SignAuthorizationReturnType into a plain serializable object
+* suitable for JSON transport to the sponsorship API.
+*
+* @not-instrumented
+*/
+const toSerializedAuthorization = (auth) => {
+	assertDefined(auth.yParity, "Signed authorization is missing yParity");
+	return {
+		address: auth.address,
+		chainId: auth.chainId,
+		nonce: auth.nonce,
+		r: auth.r,
+		s: auth.s,
+		yParity: auth.yParity
+	};
+};
+
+//#endregion
+//#region src/gasless/signSponsoredTransaction/signSponsoredTransaction.ts
+/**
+* Signs a sponsored transaction by creating an EIP-712 intent signature.
+*
+* 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. Takes priority over autoDelegate.
+* @param [params.autoDelegate] - Whether to auto-sign 7702 if not delegated. Defaults to true.
+* @param [params.nonce] - Optional bitmap nonce. When provided, nonce generation (and its on-chain check) is skipped and the supplied value is used.
+* @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, autoDelegate = true, nonce: providedNonce, 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 = providedNonce ?? 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,
+			verifyingContract: DELEGATION_CONTRACT_ADDRESS
+		},
+		message: {
+			calls: calls.map((c) => ({
+				data: c.data,
+				target: c.target,
+				value: c.value
+			})),
+			deadline,
+			mode: BATCH_CALL_OPDATA_AUTH_MODE,
+			nonce,
+			relayer: relayerAddress
+		},
+		primaryType: "AuthorizedExecutions",
+		types: AUTHORIZED_EXECUTIONS_TYPES
+	});
+	return {
+		authorization: resolvedAuthorization ? toSerializedAuthorization(resolvedAuthorization) : void 0,
+		calls,
+		chainId,
+		deadline: deadline.toString(),
+		nonce: nonce.toString(),
+		relayer: relayerAddress,
+		signature,
+		walletAddress: walletAccount.address
+	};
+};
+
+//#endregion
+//#region src/gasless/relaySponsoredTransaction/relaySponsoredTransaction.ts
+const isSignedTransactionParams = (params) => "signedTransaction" in params;
+/**
+* Relays a sponsored EVM transaction to the Dynamic backend.
+*
+* Accepts either a pre-signed transaction or unsigned calls. When given
+* unsigned calls, signs the transaction first via signSponsoredTransaction.
+*
+* The backend encodes the transaction, submits it to the relay provider,
+* and returns a request ID for tracking. The relay may retry the on-chain
+* submission, so the request ID (not a transaction hash) is the stable
+* identifier for the sponsored transaction.
+*
+* @param params - Either { signedTransaction } or { walletAccount, calls, ... }.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns An object containing the request ID for tracking the relayed transaction.
+* @throws {SponsorTransactionError} If the API call fails or returns an unexpected response.
+* @not-instrumented
+*/
+const relaySponsoredTransaction = async (params, client = getDefaultClient$1()) => {
+	const signedTransaction = isSignedTransactionParams(params) ? params.signedTransaction : await signSponsoredTransaction({
+		authorization: params.authorization,
+		autoDelegate: params.autoDelegate,
+		calls: params.calls,
+		nonce: params.nonce,
+		validForSeconds: params.validForSeconds ?? DEFAULT_VALID_FOR_SECONDS,
+		walletAccount: params.walletAccount
+	}, client);
+	const core = getCore(client);
+	const apiClient = createApiClient({}, client);
+	let data;
+	try {
+		data = await apiClient.sponsorEVMTransaction({
+			environmentId: core.environmentId,
+			sponsorEVMTransactionRequest: {
+				authorization: signedTransaction.authorization,
+				calls: signedTransaction.calls.map((c) => ({
+					data: c.data,
+					target: c.target,
+					value: c.value.toString()
+				})),
+				chainId: signedTransaction.chainId,
+				deadline: signedTransaction.deadline,
+				nonce: signedTransaction.nonce,
+				relayer: signedTransaction.relayer,
+				signature: signedTransaction.signature,
+				walletAddress: signedTransaction.walletAddress
+			}
+		});
+	} catch (error) {
+		throw new SponsorTransactionError(error instanceof Error ? error : null);
+	}
+	if (!data.requestId) throw new SponsorTransactionError();
+	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 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.
+* @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 waitForSponsoredTransaction = async ({ requestId }, client = getDefaultClient()) => {
+	for (let attempt = 0; attempt < MAX_POLLING_ATTEMPTS; attempt++) {
+		const result = await getEVMSponsoredTransactionStatus({ requestId }, client);
+		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}`);
+};
+
+//#endregion
+//#region src/gasless/sendSponsoredTransaction/sendSponsoredTransaction.ts
+/**
+* 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 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.
+* @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 sendSponsoredTransaction = async (params, client = getDefaultClient()) => {
+	const { requestId } = await relaySponsoredTransaction(params, client);
+	return waitForSponsoredTransaction({ requestId }, client);
+};
+
+//#endregion
+//#region src/errors/RpcError.ts
+var RpcError = class extends BaseError {
+	constructor(args) {
+		super({
+			cause: args.cause ?? null,
+			code: args.code ?? "rpc_error",
+			details: args.details,
+			docsUrl: args.docsUrl ?? null,
+			metaMessages: args.metaMessages,
+			name: args.name ?? "RpcError",
+			shortMessage: args.shortMessage
+		});
+	}
+};
+
+//#endregion
+//#region src/utils/fetchEvmBalance/fetchEvmBalance.ts
+/** @not-instrumented */
+const fetchEvmBalance = async ({ address, networkData }, client) => {
+	const rpcUrl = networkData.rpcUrls.http[0];
+	const core = getCore(client);
+	try {
+		const response = await core.fetch(rpcUrl, {
+			body: JSON.stringify({
+				id: Math.floor(Date.now() + Math.random() * 1e3),
+				jsonrpc: "2.0",
+				method: "eth_getBalance",
+				params: [address, "latest"]
+			}),
+			headers: { "Content-Type": "application/json" },
+			method: "POST"
+		});
+		if (!response.ok) throw new RpcError({
+			code: "http_error",
+			shortMessage: `HTTP error! status: ${response.status}`
+		});
+		const data = await response.json();
+		if (data.error) throw new RpcError({
+			cause: data.error instanceof Error ? data.error : void 0,
+			code: "json_rpc_error",
+			shortMessage: `RPC Error: ${data.error.message}`
+		});
+		const balanceWeiHex = data.result;
+		const balanceWei = BigInt(balanceWeiHex);
+		const oneEther = BigInt(0xde0b6b3a7640000);
+		return (Number(balanceWei) / Number(oneEther)).toString();
+	} catch (error) {
+		if (error instanceof Error) throw new RpcError({
+			cause: error,
+			code: "rpc_error",
+			shortMessage: `Failed to fetch balance for address ${address}`
+		});
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/utils/createEvmNetworkProvider/createEvmNetworkProvider.ts
+/** @not-instrumented */
+const createEvmNetworkProvider = (networkData, client) => ({
+	...createBaseNetworkProvider("EVM", networkData),
+	getBalance: async ({ address }) => ({ balance: await fetchEvmBalance({
+		address,
+		networkData
+	}, client) })
+});
+
+//#endregion
+//#region src/registerEvmNetworkProviderBuilder/registerEvmNetworkProviderBuilder.ts
+/** @not-instrumented */
+const registerEvmNetworkProviderBuilder = (client) => {
+	const networkProviderBuilderRegistry = getNetworkProviderBuilderRegistry(client);
+	/**
+	* If the Ethereum network provider builder is already registered, return.
+	*/
+	if (networkProviderBuilderRegistry.get().get("EVM")) return;
+	networkProviderBuilderRegistry.register({
+		builder: (networkData) => createEvmNetworkProvider(networkData, client),
+		chain: "EVM"
+	});
+};
+
+//#endregion
+//#region src/utils/isEvmWalletAccount/isEvmWalletAccount.ts
+/**
+* Type guard function to check if a wallet account is an EVM wallet account.
+*
+* @param walletAccount - The wallet account to check.
+* @returns True if the wallet account is an EVM wallet account, false otherwise.
+* @not-instrumented
+*/
+const isEvmWalletAccount = (walletAccount) => walletAccount.chain === "EVM";
+
+//#endregion
+//#region src/utils/evmConfirmTransaction/evmConfirmTransaction.ts
+/**
+* Waits for an EVM transaction to be confirmed on-chain.
+*
+* @param params.transactionHash - The transaction hash to wait for.
+* @param params.walletAccount - The EVM wallet account used to resolve the active network.
+* @param client - The Dynamic client instance.
+* @not-instrumented
+*/
+const evmConfirmTransaction = async ({ transactionHash, walletAccount }, client) => {
+	if (!isEvmWalletAccount(walletAccount)) throw new InvalidParamError("Wallet account is not an EVM wallet account");
+	const { networkData } = await getActiveNetworkData({ walletAccount }, client);
+	assertDefined(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	await createPublicClientFromNetworkData({ networkData }).waitForTransactionReceipt({ hash: 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()) => {
+	assertDefined(client.projectSettings, "Project settings are not defined");
+	return client.projectSettings.sdk.embeddedWallets?.evmGasSponsorshipEnabled ?? false;
+};
+
+//#endregion
+//#region src/utils/approveErc20/approveErc20.ts
+/**
+* Sends an ERC-20 `approve` transaction, granting a spender an allowance
+* to transfer tokens on behalf of the wallet account.
+*
+* Encodes the `approve(spender, amount)` call using viem's `encodeFunctionData`
+* and sends it through the wallet account's viem wallet client.
+*
+* @param params.amount - The amount to approve in the token's smallest unit.
+* @param params.spenderAddress - The address being granted the allowance.
+* @param params.tokenAddress - The ERC-20 token contract address.
+* @param params.walletAccount - The EVM wallet account sending the approval.
+* @param client - The Dynamic client instance.
+* @returns The approval transaction hash.
+* @not-instrumented
+*/
+const approveErc20 = async ({ amount, spenderAddress, tokenAddress, walletAccount }, client) => {
+	const walletClient = await createWalletClientForWalletAccount({ walletAccount }, client);
+	const data = encodeFunctionData({
+		abi: erc20Abi,
+		args: [spenderAddress, amount],
+		functionName: "approve"
+	});
+	return { transactionHash: await walletClient.sendTransaction({
+		data,
+		to: tokenAddress
+	}) };
+};
+
+//#endregion
+//#region src/utils/getErc20Allowance/getErc20Allowance.ts
+/**
+* Reads the current ERC-20 token allowance granted by an owner to a spender.
+*
+* Uses a viem public client derived from the wallet account's active network
+* to call the `allowance(owner, spender)` method on the token contract.
+*
+* @param params.tokenAddress - The ERC-20 token contract address.
+* @param params.ownerAddress - The address that granted the allowance.
+* @param params.spenderAddress - The address allowed to spend the tokens.
+* @param params.walletAccount - The EVM wallet account used to resolve the active network.
+* @param [params.networkData] - The network data to use for the public client. If not provided, the active network data will be used.
+* @param client - The Dynamic client instance.
+* @returns The current allowance as a bigint in the token's smallest unit.
+* @not-instrumented
+*/
+const getErc20Allowance = async ({ networkData, ownerAddress, spenderAddress, tokenAddress, walletAccount }, client) => {
+	if (!networkData) networkData = (await getActiveNetworkData({ walletAccount }, client)).networkData;
+	assertDefined(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	return createPublicClientFromNetworkData({ networkData }).readContract({
+		abi: erc20Abi,
+		address: tokenAddress,
+		args: [ownerAddress, spenderAddress],
+		functionName: "allowance"
+	});
+};
+
+//#endregion
+//#region src/utils/approveErc20IfRequiredAndWaitReceipt/approveErc20IfRequiredAndWaitReceipt.ts
+/**
+* Approves an ERC-20 token if the current allowance is insufficient and waits for the transaction receipt.
+*
+* @param params.amount - The amount of tokens to approve.
+* @param params.ownerAddress - The address that granted the allowance.
+* @param params.spenderAddress - The address allowed to spend the tokens.
+* @param params.tokenAddress - The ERC-20 token contract address.
+* @param params.walletAccount - The EVM wallet account used to resolve the active network.
+* @param client - The Dynamic client instance.
+* @returns The transaction receipt if an approval was sent, otherwise undefined.
+* @not-instrumented
+*/
+const approveErc20IfRequiredAndWaitReceipt = async ({ amount, spenderAddress, tokenAddress, walletAccount }, client) => {
+	const { networkData } = await getActiveNetworkData({ walletAccount }, client);
+	assertDefined(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	const currentAllowance = await getErc20Allowance({
+		networkData,
+		ownerAddress: walletAccount.address,
+		spenderAddress,
+		tokenAddress,
+		walletAccount
+	}, client);
+	const approvalAmount = BigInt(amount);
+	if (currentAllowance >= approvalAmount) return;
+	const approvalTransactionHash = (await approveErc20({
+		amount: approvalAmount,
+		spenderAddress,
+		tokenAddress,
+		walletAccount
+	}, client)).transactionHash;
+	return { receipt: await createPublicClientFromNetworkData({ networkData }).waitForTransactionReceipt({ hash: approvalTransactionHash }) };
+};
+
+//#endregion
+//#region src/utils/evmExecuteSponsoredSwapTransaction/evmExecuteSponsoredSwapTransaction.ts
+/**
+* Executes an EVM swap as a single gas-sponsored transaction.
+*
+* Unlike the user-paid path, the optional ERC-20 approval and the swap call
+* are batched into one sponsored transaction (EVM gas sponsorship supports
+* call batching), so there is no separate approval transaction hash.
+*
+* 1. If the signing payload includes an `evmApproval`, reads the current
+*    allowance and prepends an `approve` call only when it is insufficient
+* 2. Appends the main swap call (gas fields are dropped — the relayer pays gas)
+* 3. Relays the batch via `sendSponsoredTransaction` and waits for inclusion
+*
+* @param params.signingPayload - The signing payload containing `evmTransaction` and optional `evmApproval`.
+* @param params.walletAccount - The embedded EVM wallet account whose gas is sponsored.
+* @param params.onStepChange - Optional callback invoked with `'approval'` or `'transaction'` as each step begins.
+* @param client - The Dynamic client instance.
+* @returns The on-chain transaction hash of the sponsored swap.
+* @not-instrumented
+*/
+const evmExecuteSponsoredSwapTransaction = async ({ onStepChange, signingPayload, walletAccount }, client) => {
+	const { evmTransaction, evmApproval } = signingPayload;
+	if (!evmTransaction) throw new InvalidParamError("Signing payload is missing EVM transaction data");
+	const calls = [];
+	if (evmApproval) {
+		const approvalAmount = BigInt(evmApproval.amount);
+		if (await getErc20Allowance({
+			ownerAddress: walletAccount.address,
+			spenderAddress: evmApproval.spenderAddress,
+			tokenAddress: evmApproval.tokenAddress,
+			walletAccount
+		}, client) < approvalAmount) {
+			onStepChange?.("approval");
+			calls.push({
+				data: encodeFunctionData({
+					abi: erc20Abi,
+					args: [evmApproval.spenderAddress, approvalAmount],
+					functionName: "approve"
+				}),
+				target: evmApproval.tokenAddress,
+				value: 0n
+			});
+		}
+	}
+	onStepChange?.("transaction");
+	calls.push({
+		data: evmTransaction.data,
+		target: evmTransaction.to,
+		value: evmTransaction.value ? BigInt(evmTransaction.value) : 0n
+	});
+	const { transactionHash } = await sendSponsoredTransaction({
+		calls,
+		walletAccount
+	}, client);
+	return { transactionHash };
+};
+
+//#endregion
+//#region src/utils/evmExecuteSwapTransaction/evmExecuteSwapTransaction.ts
+/**
+* Executes an EVM checkout transaction by handling optional ERC-20 approval
+* and sending the main swap transaction on-chain.
+*
+* 1. Validates that the wallet account is an EVM wallet account
+* 2. When EVM gas sponsorship is enabled and the wallet is a Dynamic embedded
+*    wallet (and `sponsorshipMode` is not `'off'`), routes the swap through the
+*    gas-sponsored path, batching any required approval with the swap call
+* 3. Otherwise, if the signing payload includes an `evmApproval`, checks the
+*    current ERC-20 allowance and sends an approve transaction when insufficient
+* 4. Sends the main transaction using the viem wallet client
+*
+* @param params.signingPayload - The chain-aware signing payload containing `evmTransaction` and optional `evmApproval`.
+* @param params.walletAccount - The wallet account used to sign and send transactions.
+* @param params.onStepChange - Optional callback invoked with `'approval'` or `'transaction'` as each step begins.
+* @param params.sponsorshipMode - `'auto'` (default) sponsors when eligible; `'off'` never sponsors.
+* @param client - The Dynamic client instance.
+* @returns The main transaction hash and, if a separate approval was sent, the approval transaction hash.
+* @not-instrumented
+*/
+const evmExecuteSwapTransaction = async ({ onStepChange, signingPayload, sponsorshipMode = "auto", walletAccount }, client) => {
+	if (!isEvmWalletAccount(walletAccount)) throw new InvalidParamError("Wallet account is not an EVM wallet account");
+	const walletProvider = getWalletProviderFromWalletAccount({ walletAccount }, client);
+	if (sponsorshipMode === "auto" && isEvmGasSponsorshipEnabled(client) && isEvmWalletProviderWithCustomViemClient(walletProvider)) return evmExecuteSponsoredSwapTransaction({
+		onStepChange,
+		signingPayload,
+		walletAccount
+	}, client);
+	const { evmTransaction, evmApproval } = signingPayload;
+	if (!evmTransaction) throw new InvalidParamError("Signing payload is missing EVM transaction data");
+	if (evmApproval) {
+		onStepChange?.("approval");
+		await approveErc20IfRequiredAndWaitReceipt({
+			amount: evmApproval.amount,
+			spenderAddress: evmApproval.spenderAddress,
+			tokenAddress: evmApproval.tokenAddress,
+			walletAccount
+		}, client);
+	}
+	onStepChange?.("transaction");
+	const walletClient = await createWalletClientForWalletAccount({ walletAccount }, client);
+	let gasParams = {};
+	if (evmTransaction.maxFeePerGas && evmTransaction.maxPriorityFeePerGas) gasParams = {
+		maxFeePerGas: BigInt(evmTransaction.maxFeePerGas),
+		maxPriorityFeePerGas: BigInt(evmTransaction.maxPriorityFeePerGas)
+	};
+	else gasParams = { ...evmTransaction.gasPrice && { gasPrice: BigInt(evmTransaction.gasPrice) } };
+	return { transactionHash: await walletClient.sendTransaction({
+		data: evmTransaction.data,
+		to: evmTransaction.to,
+		value: evmTransaction.value ? BigInt(evmTransaction.value) : 0n,
+		...evmTransaction.gasLimit && { gas: BigInt(evmTransaction.gasLimit) },
+		...gasParams,
+		...evmTransaction.nonce && { nonce: evmTransaction.nonce }
+	}) };
+};
+
+//#endregion
+//#region src/utils/evmTransferAmount/evmTransferAmount.ts
+const DEFAULT_DECIMALS = 18;
+/** @not-instrumented */
+const evmTransferAmount = async ({ amount, recipient, token, walletAccount }, client) => {
+	if (!isEvmWalletAccount(walletAccount)) throw new InvalidParamError("Wallet account is not an EVM wallet account");
+	const { networkData } = await getActiveNetworkData({ walletAccount }, client);
+	assertDefined(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	const nonce = await createPublicClientFromNetworkData({ networkData }).getTransactionCount({ address: walletAccount.address });
+	const walletClient = await createWalletClientForWalletAccount({ walletAccount }, client);
+	if (token) {
+		const data = encodeFunctionData({
+			abi: erc20Abi,
+			args: [recipient, parseUnits(amount, token.decimals ?? DEFAULT_DECIMALS)],
+			functionName: "transfer"
+		});
+		return { transactionHash: await walletClient.sendTransaction({
+			data,
+			nonce,
+			to: token.address
+		}) };
+	}
+	return { transactionHash: await walletClient.sendTransaction({
+		nonce,
+		to: recipient,
+		value: parseEther(amount)
+	}) };
+};
+
+//#endregion
+export { isEvmWalletAccount as a, sendSponsoredTransaction as c, relaySponsoredTransaction as d, signSponsoredTransaction as f, SponsorTransactionError as h, evmConfirmTransaction as i, waitForSponsoredTransaction as l, is7702DelegationActive as m, evmExecuteSwapTransaction as n, registerEvmNetworkProviderBuilder as o, sign7702Authorization as p, isEvmGasSponsorshipEnabled as r, RpcError as s, evmTransferAmount as t, getEVMSponsoredTransactionStatus as u };
+//# sourceMappingURL=evmTransferAmount-BQDSXSva.native.esm.js.map