@dynamic-labs-sdk/evm 1.3.0 → 1.5.0

package/dist/evmTransferAmount-Bb1YvuCX.cjs

@@ -0,0 +1,964 @@
+const require_createWalletClientForWalletAccount = require('./createWalletClientForWalletAccount-CTDnbreU.cjs');
+let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
+let viem = require("viem");
+let viem_actions = require("viem/actions");
+
+//#region src/errors/SponsorTransactionError/SponsorTransactionError.ts
+var SponsorTransactionError = class extends _dynamic_labs_sdk_client.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 (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, client);
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	const publicClient = require_createWalletClientForWalletAccount.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 = (0, _dynamic_labs_sdk_client_core.getCore)(client);
+	const apiClient = (0, _dynamic_labs_sdk_client_core.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 = (0, _dynamic_labs_sdk_client_core.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 = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	const { networkData } = await (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, client);
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	const chainId = require_createWalletClientForWalletAccount.mapNetworkDataToViemChain(networkData).id;
+	const registry = get7702DelegationRegistry(client);
+	if (registry.isDelegated({
+		chainId,
+		walletAddress: walletAccount.address
+	})) return true;
+	const bytecode = await require_createWalletClientForWalletAccount.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 (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, client);
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	return require_createWalletClientForWalletAccount.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 = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	return (0, viem_actions.signAuthorization)(await require_createWalletClientForWalletAccount.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) => {
+	(0, _dynamic_labs_sdk_client_core.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 = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	const { networkData } = await (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, client);
+	(0, _dynamic_labs_sdk_client_core.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 = require_createWalletClientForWalletAccount.mapNetworkDataToViemChain(networkData).id;
+	const { relayerAddress } = await getAvailableEvmGaslessRelayer({ chainId }, client);
+	const signature = await (await require_createWalletClientForWalletAccount.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 = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	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 = (0, _dynamic_labs_sdk_client_core.getCore)(client);
+	const apiClient = (0, _dynamic_labs_sdk_client_core.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 = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	const core = (0, _dynamic_labs_sdk_client_core.getCore)(client);
+	const apiClient = (0, _dynamic_labs_sdk_client_core.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 = (0, _dynamic_labs_sdk_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 = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => {
+	const { requestId } = await relaySponsoredTransaction(params, client);
+	return waitForSponsoredTransaction({ requestId }, client);
+};
+
+//#endregion
+//#region src/errors/RpcError.ts
+var RpcError = class extends _dynamic_labs_sdk_client.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 = (0, _dynamic_labs_sdk_client_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) => ({
+	...(0, _dynamic_labs_sdk_client_core.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 = (0, _dynamic_labs_sdk_client_core.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 _dynamic_labs_sdk_client.InvalidParamError("Wallet account is not an EVM wallet account");
+	const { networkData } = await (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, client);
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	await require_createWalletClientForWalletAccount.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 = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => {
+	(0, _dynamic_labs_sdk_client_core.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 require_createWalletClientForWalletAccount.createWalletClientForWalletAccount({ walletAccount }, client);
+	const data = (0, viem.encodeFunctionData)({
+		abi: viem.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 (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, client)).networkData;
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	return require_createWalletClientForWalletAccount.createPublicClientFromNetworkData({ networkData }).readContract({
+		abi: viem.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 (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, client);
+	(0, _dynamic_labs_sdk_client_core.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 require_createWalletClientForWalletAccount.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 _dynamic_labs_sdk_client.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: (0, viem.encodeFunctionData)({
+					abi: viem.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 _dynamic_labs_sdk_client.InvalidParamError("Wallet account is not an EVM wallet account");
+	const walletProvider = (0, _dynamic_labs_sdk_client_core.getWalletProviderFromWalletAccount)({ walletAccount }, client);
+	if (sponsorshipMode === "auto" && isEvmGasSponsorshipEnabled(client) && require_createWalletClientForWalletAccount.isEvmWalletProviderWithCustomViemClient(walletProvider)) return evmExecuteSponsoredSwapTransaction({
+		onStepChange,
+		signingPayload,
+		walletAccount
+	}, client);
+	const { evmTransaction, evmApproval } = signingPayload;
+	if (!evmTransaction) throw new _dynamic_labs_sdk_client.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 require_createWalletClientForWalletAccount.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 _dynamic_labs_sdk_client.InvalidParamError("Wallet account is not an EVM wallet account");
+	const { networkData } = await (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, client);
+	(0, _dynamic_labs_sdk_client_core.assertDefined)(networkData, `No network data found for wallet account ${walletAccount.address}`);
+	const nonce = await require_createWalletClientForWalletAccount.createPublicClientFromNetworkData({ networkData }).getTransactionCount({ address: walletAccount.address });
+	const walletClient = await require_createWalletClientForWalletAccount.createWalletClientForWalletAccount({ walletAccount }, client);
+	if (token) {
+		const data = (0, viem.encodeFunctionData)({
+			abi: viem.erc20Abi,
+			args: [recipient, (0, viem.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: (0, viem.parseEther)(amount)
+	}) };
+};
+
+//#endregion
+Object.defineProperty(exports, 'RpcError', {
+  enumerable: true,
+  get: function () {
+    return RpcError;
+  }
+});
+Object.defineProperty(exports, 'SponsorTransactionError', {
+  enumerable: true,
+  get: function () {
+    return SponsorTransactionError;
+  }
+});
+Object.defineProperty(exports, 'evmConfirmTransaction', {
+  enumerable: true,
+  get: function () {
+    return evmConfirmTransaction;
+  }
+});
+Object.defineProperty(exports, 'evmExecuteSwapTransaction', {
+  enumerable: true,
+  get: function () {
+    return evmExecuteSwapTransaction;
+  }
+});
+Object.defineProperty(exports, 'evmTransferAmount', {
+  enumerable: true,
+  get: function () {
+    return evmTransferAmount;
+  }
+});
+Object.defineProperty(exports, 'getEVMSponsoredTransactionStatus', {
+  enumerable: true,
+  get: function () {
+    return getEVMSponsoredTransactionStatus;
+  }
+});
+Object.defineProperty(exports, 'is7702DelegationActive', {
+  enumerable: true,
+  get: function () {
+    return is7702DelegationActive;
+  }
+});
+Object.defineProperty(exports, 'isEvmGasSponsorshipEnabled', {
+  enumerable: true,
+  get: function () {
+    return isEvmGasSponsorshipEnabled;
+  }
+});
+Object.defineProperty(exports, 'isEvmWalletAccount', {
+  enumerable: true,
+  get: function () {
+    return isEvmWalletAccount;
+  }
+});
+Object.defineProperty(exports, 'registerEvmNetworkProviderBuilder', {
+  enumerable: true,
+  get: function () {
+    return registerEvmNetworkProviderBuilder;
+  }
+});
+Object.defineProperty(exports, 'relaySponsoredTransaction', {
+  enumerable: true,
+  get: function () {
+    return relaySponsoredTransaction;
+  }
+});
+Object.defineProperty(exports, 'sendSponsoredTransaction', {
+  enumerable: true,
+  get: function () {
+    return sendSponsoredTransaction;
+  }
+});
+Object.defineProperty(exports, 'sign7702Authorization', {
+  enumerable: true,
+  get: function () {
+    return sign7702Authorization;
+  }
+});
+Object.defineProperty(exports, 'signSponsoredTransaction', {
+  enumerable: true,
+  get: function () {
+    return signSponsoredTransaction;
+  }
+});
+Object.defineProperty(exports, 'waitForSponsoredTransaction', {
+  enumerable: true,
+  get: function () {
+    return waitForSponsoredTransaction;
+  }
+});
+//# sourceMappingURL=evmTransferAmount-Bb1YvuCX.cjs.map