@dynamic-labs/ethereum-gasless-core 0.0.0 → 4.84.0

package/src/lib/generateIntentNonce/generateIntentNonce.js

@@ -0,0 +1,35 @@
+'use client'
+import { UGD_ABI } from '../constants.js';
+import { generateRandomNonce } from '../generateRandomNonce/generateRandomNonce.js';
+
+/**
+ * Generates a random 256-bit bitmap nonce for UGD `AuthorizedExecutions`
+ * signing.
+ *
+ * Uses `crypto.getRandomValues` for entropy; collisions are essentially
+ * impossible at 256 bits. As a safety check the freshly-generated nonce is
+ * validated against the on-chain `isNonceUsed` view — if the contract call
+ * fails (e.g. delegation not yet active), the random nonce is still safe to
+ * use because it was generated locally with 256 bits of entropy.
+ */
+const generateIntentNonce = async ({ walletAddress }, { publicClient }) => {
+    const nonce = generateRandomNonce();
+    try {
+        const isUsed = await publicClient.readContract({
+            abi: UGD_ABI,
+            address: walletAddress,
+            args: [nonce],
+            functionName: 'isNonceUsed',
+        });
+        if (isUsed) {
+            return generateRandomNonce();
+        }
+    }
+    catch {
+        // Contract call may fail if delegation is not yet active — the nonce is
+        // still safe to use since it was randomly generated.
+    }
+    return nonce;
+};
+
+export { generateIntentNonce };

package/src/lib/generateRandomNonce/generateRandomNonce.cjs

@@ -0,0 +1,22 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Generates a cryptographically random 256-bit nonce for the UGD
+ * AuthorizedExecutions bitmap.
+ *
+ * Uses `crypto.getRandomValues` for 256 bits of entropy. Collisions against
+ * the on-chain bitmap are effectively impossible at this width but callers
+ * may still validate via `isNonceUsed` as a safety net.
+ *
+ * @returns A random bigint nonce.
+ */
+const generateRandomNonce = () => {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return bytes.reduce((acc, byte) => (acc << BigInt(8)) | BigInt(byte), BigInt(0));
+};
+
+exports.generateRandomNonce = generateRandomNonce;

package/src/lib/generateRandomNonce/generateRandomNonce.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generates a cryptographically random 256-bit nonce for the UGD
+ * AuthorizedExecutions bitmap.
+ *
+ * Uses `crypto.getRandomValues` for 256 bits of entropy. Collisions against
+ * the on-chain bitmap are effectively impossible at this width but callers
+ * may still validate via `isNonceUsed` as a safety net.
+ *
+ * @returns A random bigint nonce.
+ */
+export declare const generateRandomNonce: () => bigint;

package/src/lib/generateRandomNonce/generateRandomNonce.js

@@ -0,0 +1,18 @@
+'use client'
+/**
+ * Generates a cryptographically random 256-bit nonce for the UGD
+ * AuthorizedExecutions bitmap.
+ *
+ * Uses `crypto.getRandomValues` for 256 bits of entropy. Collisions against
+ * the on-chain bitmap are effectively impossible at this width but callers
+ * may still validate via `isNonceUsed` as a safety net.
+ *
+ * @returns A random bigint nonce.
+ */
+const generateRandomNonce = () => {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return bytes.reduce((acc, byte) => (acc << BigInt(8)) | BigInt(byte), BigInt(0));
+};
+
+export { generateRandomNonce };

package/src/lib/getAvailableEvmGaslessRelayer/getAvailableEvmGaslessRelayer.cjs

@@ -0,0 +1,35 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SponsorTransactionError = require('../errors/SponsorTransactionError/SponsorTransactionError.cjs');
+
+/**
+ * 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.
+ */
+const getAvailableEvmGaslessRelayer = async ({ chainId }, { sdkApi, environmentId }) => {
+    let data;
+    try {
+        data = await sdkApi.getAvailableEVMGaslessRelayer({
+            chainId,
+            environmentId,
+        });
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error : null;
+        throw new SponsorTransactionError.SponsorTransactionError(cause);
+    }
+    if (!data.relayerAddress) {
+        throw new SponsorTransactionError.SponsorTransactionError();
+    }
+    return { relayerAddress: data.relayerAddress };
+};
+
+exports.getAvailableEvmGaslessRelayer = getAvailableEvmGaslessRelayer;

package/src/lib/getAvailableEvmGaslessRelayer/getAvailableEvmGaslessRelayer.d.ts

@@ -0,0 +1,21 @@
+import type { Hex } from 'viem';
+import type { EvmGaslessApiDeps } from '../types';
+type GetAvailableEvmGaslessRelayerParams = {
+    /** The EVM chain ID the sponsored transaction will target. */
+    chainId: number;
+};
+type GetAvailableEvmGaslessRelayerResult = {
+    /** Relayer EOA that will broadcast the sponsored transaction on-chain. */
+    relayerAddress: Hex;
+};
+/**
+ * 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.
+ */
+export declare const getAvailableEvmGaslessRelayer: ({ chainId }: GetAvailableEvmGaslessRelayerParams, { sdkApi, environmentId }: EvmGaslessApiDeps) => Promise<GetAvailableEvmGaslessRelayerResult>;
+export {};

package/src/lib/getAvailableEvmGaslessRelayer/getAvailableEvmGaslessRelayer.js

@@ -0,0 +1,31 @@
+'use client'
+import { SponsorTransactionError } from '../errors/SponsorTransactionError/SponsorTransactionError.js';
+
+/**
+ * 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.
+ */
+const getAvailableEvmGaslessRelayer = async ({ chainId }, { sdkApi, environmentId }) => {
+    let data;
+    try {
+        data = await sdkApi.getAvailableEVMGaslessRelayer({
+            chainId,
+            environmentId,
+        });
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error : null;
+        throw new SponsorTransactionError(cause);
+    }
+    if (!data.relayerAddress) {
+        throw new SponsorTransactionError();
+    }
+    return { relayerAddress: data.relayerAddress };
+};
+
+export { getAvailableEvmGaslessRelayer };

package/src/lib/getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.cjs

@@ -0,0 +1,35 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var SponsorTransactionError = require('../errors/SponsorTransactionError/SponsorTransactionError.cjs');
+
+/**
+ * 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`.
+ */
+const getEVMSponsoredTransactionStatus = async ({ requestId }, { sdkApi, environmentId }) => {
+    let data;
+    try {
+        data = await sdkApi.getEVMSponsoredTransactionStatus({
+            environmentId,
+            requestId,
+        });
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error : null;
+        throw new SponsorTransactionError.SponsorTransactionError(cause);
+    }
+    return {
+        errorMessage: data.errorMessage,
+        status: data.status,
+        transactionHash: data.transactionHash,
+    };
+};
+
+exports.getEVMSponsoredTransactionStatus = getEVMSponsoredTransactionStatus;

package/src/lib/getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.d.ts

@@ -0,0 +1,15 @@
+import type { EvmGaslessApiDeps, SponsoredTransactionStatusResult } from '../types';
+type GetEVMSponsoredTransactionStatusParams = {
+    /** The request ID returned by `relaySponsoredTransaction` / `sendSponsoredTransaction`. */
+    requestId: string;
+};
+/**
+ * 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`.
+ */
+export declare const getEVMSponsoredTransactionStatus: ({ requestId }: GetEVMSponsoredTransactionStatusParams, { sdkApi, environmentId }: EvmGaslessApiDeps) => Promise<SponsoredTransactionStatusResult>;
+export {};

package/src/lib/getEVMSponsoredTransactionStatus/getEVMSponsoredTransactionStatus.js

@@ -0,0 +1,31 @@
+'use client'
+import { SponsorTransactionError } from '../errors/SponsorTransactionError/SponsorTransactionError.js';
+
+/**
+ * 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`.
+ */
+const getEVMSponsoredTransactionStatus = async ({ requestId }, { sdkApi, environmentId }) => {
+    let data;
+    try {
+        data = await sdkApi.getEVMSponsoredTransactionStatus({
+            environmentId,
+            requestId,
+        });
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error : null;
+        throw new SponsorTransactionError(cause);
+    }
+    return {
+        errorMessage: data.errorMessage,
+        status: data.status,
+        transactionHash: data.transactionHash,
+    };
+};
+
+export { getEVMSponsoredTransactionStatus };

package/src/lib/is7702DelegationActive/is7702DelegationActive.cjs

@@ -0,0 +1,32 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.cjs');
+
+/**
+ * Checks whether EIP-7702 delegation to the Dynamic gasless contract is
+ * active for the given wallet on the given chain.
+ *
+ * Positive results are cached in the in-memory registry; missing entries
+ * fall back to an on-chain bytecode check (`eth_getCode`). The on-chain
+ * delegation marker is `DELEGATION_CODE_PREFIX + DELEGATION_CONTRACT_ADDRESS`.
+ */
+const is7702DelegationActive = async ({ walletAddress }, { chainId, delegationRegistry, publicClient }) => {
+    if (delegationRegistry.isDelegated({ chainId, walletAddress })) {
+        return true;
+    }
+    const bytecode = await publicClient.getCode({ address: walletAddress });
+    if (!bytecode) {
+        return false;
+    }
+    const expectedPrefix = constants.DELEGATION_CODE_PREFIX + constants.DELEGATION_CONTRACT_ADDRESS.slice(2).toLowerCase();
+    const isActive = bytecode.toLowerCase().startsWith(expectedPrefix);
+    if (isActive) {
+        delegationRegistry.markDelegated({ chainId, walletAddress });
+    }
+    return isActive;
+};
+
+exports.is7702DelegationActive = is7702DelegationActive;

package/src/lib/is7702DelegationActive/is7702DelegationActive.d.ts

@@ -0,0 +1,21 @@
+import type { Chain, Hex, PublicClient, Transport } from 'viem';
+import type { Delegation7702Registry } from '../types';
+type Is7702DelegationActiveParams = {
+    /** The wallet address to check delegation status for. */
+    walletAddress: Hex;
+};
+type Is7702DelegationActiveDeps = {
+    chainId: number;
+    delegationRegistry: Delegation7702Registry;
+    publicClient: PublicClient<Transport, Chain>;
+};
+/**
+ * Checks whether EIP-7702 delegation to the Dynamic gasless contract is
+ * active for the given wallet on the given chain.
+ *
+ * Positive results are cached in the in-memory registry; missing entries
+ * fall back to an on-chain bytecode check (`eth_getCode`). The on-chain
+ * delegation marker is `DELEGATION_CODE_PREFIX + DELEGATION_CONTRACT_ADDRESS`.
+ */
+export declare const is7702DelegationActive: ({ walletAddress }: Is7702DelegationActiveParams, { chainId, delegationRegistry, publicClient }: Is7702DelegationActiveDeps) => Promise<boolean>;
+export {};

package/src/lib/is7702DelegationActive/is7702DelegationActive.js

@@ -0,0 +1,28 @@
+'use client'
+import { DELEGATION_CODE_PREFIX, DELEGATION_CONTRACT_ADDRESS } from '../constants.js';
+
+/**
+ * Checks whether EIP-7702 delegation to the Dynamic gasless contract is
+ * active for the given wallet on the given chain.
+ *
+ * Positive results are cached in the in-memory registry; missing entries
+ * fall back to an on-chain bytecode check (`eth_getCode`). The on-chain
+ * delegation marker is `DELEGATION_CODE_PREFIX + DELEGATION_CONTRACT_ADDRESS`.
+ */
+const is7702DelegationActive = async ({ walletAddress }, { chainId, delegationRegistry, publicClient }) => {
+    if (delegationRegistry.isDelegated({ chainId, walletAddress })) {
+        return true;
+    }
+    const bytecode = await publicClient.getCode({ address: walletAddress });
+    if (!bytecode) {
+        return false;
+    }
+    const expectedPrefix = DELEGATION_CODE_PREFIX + DELEGATION_CONTRACT_ADDRESS.slice(2).toLowerCase();
+    const isActive = bytecode.toLowerCase().startsWith(expectedPrefix);
+    if (isActive) {
+        delegationRegistry.markDelegated({ chainId, walletAddress });
+    }
+    return isActive;
+};
+
+export { is7702DelegationActive };

package/src/lib/isEthereumGasSponsorshipEnabled/isEthereumGasSponsorshipEnabled.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Checks whether EVM gas sponsorship is enabled for the current project.
+ *
+ * Returns `false` when no project settings are available — callers can
+ * always treat the return value as a definitive boolean.
+ */
+const isEthereumGasSponsorshipEnabled = ({ projectSettings, }) => projectSettings?.sdk.embeddedWallets?.evmGasSponsorshipEnabled ?? false;
+
+exports.isEthereumGasSponsorshipEnabled = isEthereumGasSponsorshipEnabled;

package/src/lib/isEthereumGasSponsorshipEnabled/isEthereumGasSponsorshipEnabled.d.ts

@@ -0,0 +1,23 @@
+type ProjectSettingsLike = {
+    sdk: {
+        embeddedWallets?: {
+            evmGasSponsorshipEnabled?: boolean;
+        };
+    };
+};
+type IsEthereumGasSponsorshipEnabledDeps = {
+    /**
+     * The project settings object resolved by the host (e.g. from the webview
+     * manifest or the React SDK's project store). When the settings object is
+     * unavailable, returns `false`.
+     */
+    projectSettings: ProjectSettingsLike | null | undefined;
+};
+/**
+ * Checks whether EVM gas sponsorship is enabled for the current project.
+ *
+ * Returns `false` when no project settings are available — callers can
+ * always treat the return value as a definitive boolean.
+ */
+export declare const isEthereumGasSponsorshipEnabled: ({ projectSettings, }: IsEthereumGasSponsorshipEnabledDeps) => boolean;
+export {};

package/src/lib/isEthereumGasSponsorshipEnabled/isEthereumGasSponsorshipEnabled.js

@@ -0,0 +1,10 @@
+'use client'
+/**
+ * Checks whether EVM gas sponsorship is enabled for the current project.
+ *
+ * Returns `false` when no project settings are available — callers can
+ * always treat the return value as a definitive boolean.
+ */
+const isEthereumGasSponsorshipEnabled = ({ projectSettings, }) => projectSettings?.sdk.embeddedWallets?.evmGasSponsorshipEnabled ?? false;
+
+export { isEthereumGasSponsorshipEnabled };

package/src/lib/relaySponsoredTransaction/relaySponsoredTransaction.cjs

@@ -0,0 +1,58 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.cjs');
+var SponsorTransactionError = require('../errors/SponsorTransactionError/SponsorTransactionError.cjs');
+var signSponsoredTransaction = require('../signSponsoredTransaction/signSponsoredTransaction.cjs');
+
+const isSignedTransactionParams = (params) => 'signedTransaction' in params;
+/**
+ * Relays a signed sponsored transaction to the Dynamic backend.
+ *
+ * Accepts either an already-signed payload from `signSponsoredTransaction`
+ * or unsigned calls (in which case signing is performed first). Returns the
+ * `requestId` the relay backend uses to identify the broadcast attempt — use
+ * this with `waitForSponsoredTransaction` to await on-chain inclusion.
+ */
+const relaySponsoredTransaction = async (params, deps) => {
+    const signedTransaction = isSignedTransactionParams(params)
+        ? params.signedTransaction
+        : await signSponsoredTransaction.signSponsoredTransaction({
+            authorization: params.authorization,
+            autoDelegate: params.autoDelegate,
+            calls: params.calls,
+            validForSeconds: params.validForSeconds ?? constants.DEFAULT_VALID_FOR_SECONDS,
+        }, deps);
+    let data;
+    try {
+        data = await deps.sdkApi.sponsorEVMTransaction({
+            environmentId: deps.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) {
+        const cause = error instanceof Error ? error : null;
+        throw new SponsorTransactionError.SponsorTransactionError(cause);
+    }
+    if (!data.requestId) {
+        throw new SponsorTransactionError.SponsorTransactionError();
+    }
+    return { requestId: data.requestId };
+};
+
+exports.relaySponsoredTransaction = relaySponsoredTransaction;

package/src/lib/relaySponsoredTransaction/relaySponsoredTransaction.d.ts

@@ -0,0 +1,29 @@
+import type { SignAuthorizationReturnType } from 'viem/accounts';
+import type { EvmGaslessChainDeps, SignedSponsoredTransaction, SponsoredTransactionCall } from '../types';
+type RelayWithCallsParams = {
+    /** Pre-signed EIP-7702 authorization. Takes priority over autoDelegate. */
+    authorization?: SignAuthorizationReturnType;
+    /** Whether to automatically sign 7702 authorization if not delegated. Defaults to true. */
+    autoDelegate?: boolean;
+    /** The batch of calls to execute. */
+    calls: SponsoredTransactionCall[];
+    /** How long the signed intent remains valid, in seconds. Defaults to 600. */
+    validForSeconds?: number;
+};
+type RelayWithSignedTxParams = {
+    /** A pre-signed sponsored transaction payload from `signSponsoredTransaction`. */
+    signedTransaction: SignedSponsoredTransaction;
+};
+type RelaySponsoredTransactionParams = RelayWithCallsParams | RelayWithSignedTxParams;
+/**
+ * Relays a signed sponsored transaction to the Dynamic backend.
+ *
+ * Accepts either an already-signed payload from `signSponsoredTransaction`
+ * or unsigned calls (in which case signing is performed first). Returns the
+ * `requestId` the relay backend uses to identify the broadcast attempt — use
+ * this with `waitForSponsoredTransaction` to await on-chain inclusion.
+ */
+export declare const relaySponsoredTransaction: (params: RelaySponsoredTransactionParams, deps: EvmGaslessChainDeps) => Promise<{
+    requestId: string;
+}>;
+export {};

package/src/lib/relaySponsoredTransaction/relaySponsoredTransaction.js

@@ -0,0 +1,54 @@
+'use client'
+import { DEFAULT_VALID_FOR_SECONDS } from '../constants.js';
+import { SponsorTransactionError } from '../errors/SponsorTransactionError/SponsorTransactionError.js';
+import { signSponsoredTransaction } from '../signSponsoredTransaction/signSponsoredTransaction.js';
+
+const isSignedTransactionParams = (params) => 'signedTransaction' in params;
+/**
+ * Relays a signed sponsored transaction to the Dynamic backend.
+ *
+ * Accepts either an already-signed payload from `signSponsoredTransaction`
+ * or unsigned calls (in which case signing is performed first). Returns the
+ * `requestId` the relay backend uses to identify the broadcast attempt — use
+ * this with `waitForSponsoredTransaction` to await on-chain inclusion.
+ */
+const relaySponsoredTransaction = async (params, deps) => {
+    const signedTransaction = isSignedTransactionParams(params)
+        ? params.signedTransaction
+        : await signSponsoredTransaction({
+            authorization: params.authorization,
+            autoDelegate: params.autoDelegate,
+            calls: params.calls,
+            validForSeconds: params.validForSeconds ?? DEFAULT_VALID_FOR_SECONDS,
+        }, deps);
+    let data;
+    try {
+        data = await deps.sdkApi.sponsorEVMTransaction({
+            environmentId: deps.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) {
+        const cause = error instanceof Error ? error : null;
+        throw new SponsorTransactionError(cause);
+    }
+    if (!data.requestId) {
+        throw new SponsorTransactionError();
+    }
+    return { requestId: data.requestId };
+};
+
+export { relaySponsoredTransaction };

package/src/lib/resolveAuthorization/resolveAuthorization.cjs

@@ -0,0 +1,32 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var is7702DelegationActive = require('../is7702DelegationActive/is7702DelegationActive.cjs');
+var sign7702Authorization = require('../sign7702Authorization/sign7702Authorization.cjs');
+
+/**
+ * Resolves which EIP-7702 authorization (if any) to attach to a sponsored
+ * transaction.
+ *
+ * - If the caller pre-signed an authorization, it is returned as-is.
+ * - If `autoDelegate` is false, no authorization is attached.
+ * - Otherwise, queries the on-chain delegation state. If delegation is
+ *   already active, no authorization is needed; if not, signs one.
+ */
+const resolveAuthorization = async ({ authorization, autoDelegate, walletAddress }, deps) => {
+    if (authorization) {
+        return authorization;
+    }
+    if (!autoDelegate) {
+        return undefined;
+    }
+    const isDelegated = await is7702DelegationActive.is7702DelegationActive({ walletAddress }, deps);
+    if (isDelegated) {
+        return undefined;
+    }
+    return sign7702Authorization.sign7702Authorization({}, deps);
+};
+
+exports.resolveAuthorization = resolveAuthorization;

package/src/lib/resolveAuthorization/resolveAuthorization.d.ts

@@ -0,0 +1,27 @@
+import type { Account, Chain, Hex, PublicClient, Transport, WalletClient } from 'viem';
+import type { SignAuthorizationReturnType } from 'viem/accounts';
+import type { Delegation7702Registry } from '../types';
+type ResolveAuthorizationParams = {
+    /** Pre-signed authorization; when provided it is returned as-is. */
+    authorization?: SignAuthorizationReturnType;
+    /** When true and no authorization is provided, sign one if delegation is inactive. */
+    autoDelegate: boolean;
+    walletAddress: Hex;
+};
+type ResolveAuthorizationDeps = {
+    chainId: number;
+    delegationRegistry: Delegation7702Registry;
+    publicClient: PublicClient<Transport, Chain>;
+    walletClient: WalletClient<Transport, Chain, Account>;
+};
+/**
+ * Resolves which EIP-7702 authorization (if any) to attach to a sponsored
+ * transaction.
+ *
+ * - If the caller pre-signed an authorization, it is returned as-is.
+ * - If `autoDelegate` is false, no authorization is attached.
+ * - Otherwise, queries the on-chain delegation state. If delegation is
+ *   already active, no authorization is needed; if not, signs one.
+ */
+export declare const resolveAuthorization: ({ authorization, autoDelegate, walletAddress }: ResolveAuthorizationParams, deps: ResolveAuthorizationDeps) => Promise<SignAuthorizationReturnType | undefined>;
+export {};

package/src/lib/resolveAuthorization/resolveAuthorization.js

@@ -0,0 +1,28 @@
+'use client'
+import { is7702DelegationActive } from '../is7702DelegationActive/is7702DelegationActive.js';
+import { sign7702Authorization } from '../sign7702Authorization/sign7702Authorization.js';
+
+/**
+ * Resolves which EIP-7702 authorization (if any) to attach to a sponsored
+ * transaction.
+ *
+ * - If the caller pre-signed an authorization, it is returned as-is.
+ * - If `autoDelegate` is false, no authorization is attached.
+ * - Otherwise, queries the on-chain delegation state. If delegation is
+ *   already active, no authorization is needed; if not, signs one.
+ */
+const resolveAuthorization = async ({ authorization, autoDelegate, walletAddress }, deps) => {
+    if (authorization) {
+        return authorization;
+    }
+    if (!autoDelegate) {
+        return undefined;
+    }
+    const isDelegated = await is7702DelegationActive({ walletAddress }, deps);
+    if (isDelegated) {
+        return undefined;
+    }
+    return sign7702Authorization({}, deps);
+};
+
+export { resolveAuthorization };

package/src/lib/resolveChainId/resolveChainId.cjs

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Resolves a chain ID from either an explicit override or the chain ID
+ * configured in the gasless chain deps.
+ */
+const resolveChainId = ({ chainId }, { chainId: depsChainId }) => chainId ?? depsChainId;
+
+exports.resolveChainId = resolveChainId;

package/src/lib/resolveChainId/resolveChainId.d.ts

@@ -0,0 +1,11 @@
+import type { EvmGaslessChainDeps } from '../types';
+type ResolveChainIdParams = {
+    /** Optional override; when set the deps' chainId is ignored. */
+    chainId?: number;
+};
+/**
+ * Resolves a chain ID from either an explicit override or the chain ID
+ * configured in the gasless chain deps.
+ */
+export declare const resolveChainId: ({ chainId }: ResolveChainIdParams, { chainId: depsChainId }: Pick<EvmGaslessChainDeps, 'chainId'>) => number;
+export {};