@abstraxn/signer-react 3.1.4 → 3.3.0

package/dist/src/hooks.d.ts

@@ -1,6 +1,8 @@
-import type { WhoamiResponse, TransactionRequest, EnableMfaResponse, VerifySetupMfaResponse, DisableMfaResponse } from '@abstraxn/signer-core';
+import type { WhoamiResponse, TransactionRequest, EnableMfaResponse, VerifySetupMfaResponse, DisableMfaResponse, SupportedAuthMethod, LinkedAuthMethod } from '@abstraxn/signer-core';
 import type { Chain, PublicClient, Address, Abi, GetContractReturnType, TransactionReceipt } from 'viem';
 import { Connection as SolanaConnection, Transaction as SolanaTransaction, TransactionInstruction, type Commitment, type SendOptions } from '@solana/web3.js';
+import { SolanaRelayer } from '@abstraxn/solana-relayer';
+import type { BuildTxParams as SolanaGaslessBuildTxParams, BuildRelayTxResult as SolanaGaslessBuildTxResult, RelaySubmitResponse as SolanaGaslessRelaySubmitResponse, RelayStatusResponse as SolanaGaslessRelayStatusResponse } from '@abstraxn/solana-relayer';
 import type { TypedData, TypedDataDomain } from 'viem';
 import { type ConnectorType, type ConnectorMeta } from './connectors';
 /**
@@ -46,6 +48,20 @@ export { useAbstraxnWallet } from './AbstraxnProvider';
  * Hook to get wallet instance (for advanced usage)
  */
 export declare function useWallet(): import("@abstraxn/signer-core").AbstraxnWallet | null;
+export interface SmartAccountOwnerOptions {
+    /** Override the signer address. By default, uses connected wallet address from context. */
+    address?: Address;
+}
+export interface SmartAccountOwnerResult {
+    smartAccountOwner: any | null;
+    isReady: boolean;
+    address: Address | null;
+}
+/**
+ * Hook to get an AA-compatible owner account for permissionless-compatible SDKs.
+ * This does not include bundler/paymaster integration; apps can plug in any provider.
+ */
+export declare function useSmartAccountOwner(options?: SmartAccountOwnerOptions): SmartAccountOwnerResult;
 /**
  * Hook to export wallet private key
  * Returns the export bundle containing the private key
@@ -127,6 +143,28 @@ export declare function useDisableMfa(): {
     confirmDisable: () => Promise<DisableMfaResponse | null>;
     reset: () => void;
 };
+export interface UseAuthMethodLinkingReturn {
+    supportedMethods: SupportedAuthMethod[];
+    linkedMethods: LinkedAuthMethod[];
+    loading: boolean;
+    actionProvider: string | null;
+    error: string | null;
+    refreshAuthMethods: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    isLinked: (provider: string) => boolean;
+    linkProvider: (provider: 'google' | 'discord' | 'twitter' | 'x' | 'passkey') => Promise<void>;
+    requestEmailLinkOtp: (email: string) => Promise<{
+        otpId: string;
+    }>;
+    confirmEmailLink: (otpId: string, otpCode: string) => Promise<void>;
+    unlinkProvider: (provider: string) => Promise<void>;
+}
+/**
+ * Hook for linking/unlinking auth methods without any UI concerns.
+ * It exposes state and actions only; consumers own rendering and messaging.
+ */
+export declare function useAuthMethodLinking(): UseAuthMethodLinkingReturn;
 /**
  * Hook to access external wallet functionality
  * Returns external wallet connection state and methods
@@ -270,7 +308,6 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
             request?: (parameters: import("viem").CcipRequestParameters) => Promise<import("viem/_types/utils/ccip").CcipRequestReturnType>;
         } | undefined;
         chain: Chain | undefined;
-        dataSuffix?: import("viem").DataSuffix | undefined;
         experimental_blockTag?: import("viem").BlockTag | undefined;
         key: string;
         name: string;
@@ -453,7 +490,6 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
         getChainId: () => Promise<import("viem").GetChainIdReturnType>;
         getCode: (args: import("viem").GetBytecodeParameters) => Promise<import("viem").GetBytecodeReturnType>;
         getContractEvents: <const abi extends Abi | readonly unknown[], eventName extends import("viem").ContractEventName<abi> | undefined = undefined, strict extends boolean | undefined = undefined, fromBlock extends import("viem").BlockNumber | import("viem").BlockTag | undefined = undefined, toBlock extends import("viem").BlockNumber | import("viem").BlockTag | undefined = undefined>(args: import("viem").GetContractEventsParameters<abi, eventName, strict, fromBlock, toBlock>) => Promise<import("viem").GetContractEventsReturnType<abi, eventName, strict, fromBlock, toBlock>>;
-        getDelegation: (args: import("viem").GetDelegationParameters) => Promise<import("viem").GetDelegationReturnType>;
         getEip712Domain: (args: import("viem").GetEip712DomainParameters) => Promise<import("viem").GetEip712DomainReturnType>;
         getEnsAddress: (args: import("viem").GetEnsAddressParameters) => Promise<import("viem").GetEnsAddressReturnType>;
         getEnsAvatar: (args: import("viem").GetEnsAvatarParameters) => Promise<import("viem").GetEnsAvatarReturnType>;
@@ -3879,7 +3915,6 @@ export declare function usePublicClient(chain: Chain, rpcUrl: string): {
             cacheTime?: undefined;
             ccipRead?: undefined;
             chain?: undefined;
-            dataSuffix?: undefined;
             experimental_blockTag?: undefined;
             key?: undefined;
             name?: undefined;
@@ -3929,7 +3964,6 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             request?: (parameters: import("viem").CcipRequestParameters) => Promise<import("viem/_types/utils/ccip").CcipRequestReturnType>;
         } | undefined;
         chain: Chain | undefined;
-        dataSuffix?: import("viem").DataSuffix | undefined;
         experimental_blockTag?: import("viem").BlockTag | undefined;
         key: string;
         name: string;
@@ -8341,7 +8375,6 @@ export declare function useWalletClient(chain: any, rpcUrl?: string): {
             cacheTime?: undefined;
             ccipRead?: undefined;
             chain?: undefined;
-            dataSuffix?: undefined;
             experimental_blockTag?: undefined;
             key?: undefined;
             name?: undefined;
@@ -8583,6 +8616,47 @@ export declare function useSignAndSendSolanaTxn(connection: SolanaConnection): {
     isConnected: boolean;
     solanaAddress: string | null;
 };
+export type SolanaGaslessBuildParams = Omit<SolanaGaslessBuildTxParams, 'connection' | 'sender'> & {
+    connection?: SolanaConnection;
+    sender?: string;
+};
+export interface SolanaGaslessConfigResolved {
+    enabled: boolean;
+    relayerBaseUrl: string;
+    apiKey: string;
+    networkChainId: number;
+    defaultPollMs?: number;
+    defaultTimeoutMs?: number;
+    relayerUrl: string;
+}
+export declare function useSolanaGasless(): {
+    isEnabled: boolean;
+    config: SolanaGaslessConfigResolved | null;
+    relayerClient: SolanaRelayer | null;
+    buildGaslessTx: (params: SolanaGaslessBuildParams) => Promise<SolanaGaslessBuildTxResult>;
+    signGaslessTx: (params: {
+        transaction: SolanaTransaction;
+        sender?: string;
+    }) => Promise<{
+        signedTransactionBase64: string;
+        signedTransactionHex: string;
+    }>;
+    sendGaslessTx: (params: {
+        signedTransactionBase64: string;
+        lastValidBlockHeight: number;
+    }) => Promise<SolanaGaslessRelaySubmitResponse>;
+    getGaslessTxStatus: (txnId: string) => Promise<SolanaGaslessRelayStatusResponse>;
+};
+export declare function useSignAndSendSolanaGaslessTxn(): {
+    signAndSendGaslessTx: (params: SolanaGaslessBuildParams) => Promise<{
+        txnId: string;
+        status: "pending" | "confirmed" | "processing" | "failed";
+        preview: Record<string, unknown>;
+        signedTransactionHex: string;
+        signedTransactionBase64: string;
+        lastValidBlockHeight: number;
+    }>;
+};
 /**
  * Hook to wait for Solana transaction confirmation.
  */
@@ -8868,7 +8942,6 @@ export declare function useExternalWalletClient(): {
             request?: (parameters: import("viem").CcipRequestParameters) => Promise<import("viem/_types/utils/ccip").CcipRequestReturnType>;
         } | undefined;
         chain: Chain;
-        dataSuffix?: import("viem").DataSuffix | undefined;
         experimental_blockTag?: import("viem").BlockTag | undefined;
         key: string;
         name: string;
@@ -13280,7 +13353,6 @@ export declare function useExternalWalletClient(): {
             cacheTime?: undefined;
             ccipRead?: undefined;
             chain?: undefined;
-            dataSuffix?: undefined;
             experimental_blockTag?: undefined;
             key?: undefined;
             name?: undefined;

package/dist/src/hooks.js

@@ -4,8 +4,10 @@
 import { useState, useCallback, useEffect, useMemo } from 'react';
 import { useAbstraxnWallet } from './AbstraxnProvider';
 import { InvalidDeviceIdError, SignMfaRequiredError } from '@abstraxn/signer-core';
-import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, encodeFunctionData, hashTypedData } from 'viem';
+import { createPublicClient, createWalletClient, http, getContract, serializeTransaction, encodeFunctionData, hashTypedData, hashMessage, parseSignature } from 'viem';
+import { toAccount } from 'viem/accounts';
 import { Connection as SolanaConnection, Transaction as SolanaTransaction, SystemProgram, PublicKey, LAMPORTS_PER_SOL, TransactionInstruction, } from '@solana/web3.js';
+import { SolanaRelayer } from '@abstraxn/solana-relayer';
 import { useWalletClient as useWagmiWalletClient, useAccount, useConfig, useChainId as useWagmiChainId, useSwitchChain as useWagmiSwitchChain, useSignMessage as useWagmiSignMessage, useReconnect as useWagmiReconnect } from 'wagmi';
 import { getWalletClient, switchChain } from '@wagmi/core';
 import { getConnectorMeta } from './connectors';
@@ -72,6 +74,67 @@ export function useWallet() {
     const { wallet } = useAbstraxnWallet();
     return wallet;
 }
+/**
+ * Hook to get an AA-compatible owner account for permissionless-compatible SDKs.
+ * This does not include bundler/paymaster integration; apps can plug in any provider.
+ */
+export function useSmartAccountOwner(options = {}) {
+    const { isConnected, address: connectedAddress, signTransactionViaAPI, signTypedTxViaAPI, verifySignMfa, } = useAbstraxnWallet();
+    const ownerAddress = (options.address ?? connectedAddress ?? null);
+    const smartAccountOwner = useMemo(() => {
+        if (!isConnected || !ownerAddress)
+            return null;
+        return toAccount({
+            address: ownerAddress,
+            /**
+             * ERC-4337 SimpleAccount (permissionless) signs UserOperations via viem `signMessage` with
+             * `message: { raw: userOpHash }`. That requires the same digest as viem local accounts:
+             * EIP-191 `hashMessage(message)`, then ECDSA sign that 32-byte digest — not UTF-8 text hashing.
+             */
+            async signMessage({ message }) {
+                const digest = hashMessage(message);
+                const signature = await runWithSignStepUpRetry(() => signTypedTxViaAPI(ownerAddress, digest, 'PAYLOAD_ENCODING_HEXADECIMAL', 'HASH_FUNCTION_NO_OP').then((res) => res.signature), verifySignMfa);
+                return (signature.startsWith('0x') ? signature : `0x${signature}`);
+            },
+            async signTransaction(transaction) {
+                const unsignedTransaction = serializeTransaction(transaction);
+                const result = await runWithSignStepUpRetry(() => signTransactionViaAPI(unsignedTransaction, ownerAddress), verifySignMfa);
+                return result.signedTransaction;
+            },
+            async signTypedData(typedData) {
+                const digest = hashTypedData(typedData);
+                const result = await runWithSignStepUpRetry(() => signTypedTxViaAPI(ownerAddress, digest, 'PAYLOAD_ENCODING_EIP712', 'HASH_FUNCTION_NO_OP'), verifySignMfa);
+                const signature = result.signature;
+                return (signature.startsWith('0x') ? signature : `0x${signature}`);
+            },
+            /** EIP-7702: sign delegation authorization (`keccak256(0x05 || rlp(...))`) via backend, same as raw ECDSA over digest. */
+            async signAuthorization(parameters) {
+                const authorizationAddress = parameters.contractAddress ?? parameters.address;
+                const authorizationPayload = JSON.stringify({
+                    chainId: parameters.chainId,
+                    address: authorizationAddress,
+                    nonce: parameters.nonce,
+                });
+                const sig = await runWithSignStepUpRetry(() => signTypedTxViaAPI(ownerAddress, authorizationPayload, 'PAYLOAD_ENCODING_EIP7702_AUTHORIZATION', 'HASH_FUNCTION_NOT_APPLICABLE').then((res) => res.signature), verifySignMfa);
+                const hex = (sig.startsWith('0x') ? sig : `0x${sig}`);
+                const { r, s, yParity } = parseSignature(hex);
+                return {
+                    address: authorizationAddress,
+                    chainId: parameters.chainId,
+                    nonce: parameters.nonce,
+                    r,
+                    s,
+                    yParity,
+                };
+            },
+        });
+    }, [isConnected, ownerAddress, signTransactionViaAPI, signTypedTxViaAPI, verifySignMfa]);
+    return {
+        smartAccountOwner,
+        isReady: !!smartAccountOwner,
+        address: ownerAddress,
+    };
+}
 /**
  * Hook to export wallet private key
  * Returns the export bundle containing the private key
@@ -414,6 +477,282 @@ export function useDisableMfa() {
         reset,
     };
 }
+const AUTH_METHOD_LINK_PROVIDER_ALLOWLIST = new Set([
+    'google',
+    'discord',
+    'x',
+    'passkey',
+]);
+const AUTH_METHOD_UNLINK_PROVIDER_ALLOWLIST = new Set([
+    'google',
+    'discord',
+    'x',
+    'email',
+    'passkey',
+]);
+function normalizeAuthMethodProviderForApi(provider) {
+    const normalized = provider.trim().toLowerCase();
+    if (normalized === 'otp')
+        return 'email';
+    return normalized;
+}
+function normalizeAuthMethodProviderForMatch(provider) {
+    const normalized = normalizeAuthMethodProviderForApi(provider);
+    if (normalized === 'twitter' || normalized === 'x')
+        return 'x';
+    return normalized;
+}
+function normalizeAuthMethodErrorMessage(message) {
+    return message.replace(/^network error:\s*/i, '').trim();
+}
+function toAuthMethodError(error, fallbackMessage) {
+    if (error instanceof Error) {
+        return new Error(normalizeAuthMethodErrorMessage(error.message || fallbackMessage));
+    }
+    if (typeof error === 'string' && error.trim() !== '') {
+        return new Error(normalizeAuthMethodErrorMessage(error));
+    }
+    return new Error(fallbackMessage);
+}
+/**
+ * Hook for linking/unlinking auth methods without any UI concerns.
+ * It exposes state and actions only; consumers own rendering and messaging.
+ */
+export function useAuthMethodLinking() {
+    const { wallet, whoami, getSupportedAuthMethods, getLinkedAuthMethods, requestOtpForEmailLink, loginWithOTP, } = useAbstraxnWallet();
+    const [supportedMethods, setSupportedMethods] = useState([]);
+    const [linkedMethods, setLinkedMethods] = useState([]);
+    const [queryLoading, setQueryLoading] = useState(false);
+    const [actionProvider, setActionProvider] = useState(null);
+    const [error, setError] = useState(null);
+    const requireConnectedWallet = useCallback(() => {
+        if (!wallet?.isConnected) {
+            throw new Error('Wallet not connected');
+        }
+        return wallet;
+    }, [wallet]);
+    const refreshAuthMethods = useCallback(async (_options) => {
+        const activeWallet = requireConnectedWallet();
+        setQueryLoading(true);
+        setError(null);
+        try {
+            const supportedRequest = getSupportedAuthMethods != null
+                ? getSupportedAuthMethods()
+                : activeWallet.getSupportedAuthMethods();
+            const linkedRequest = getLinkedAuthMethods != null
+                ? getLinkedAuthMethods()
+                : activeWallet.getLinkedAuthMethods();
+            const [supportedResponse, linkedResponse] = await Promise.all([
+                supportedRequest,
+                linkedRequest,
+            ]);
+            const loginProvider = normalizeAuthMethodProviderForMatch(String(whoami?.loginProvider ?? ''));
+            const allSupportedMethods = supportedResponse.supportedMethods ?? [];
+            const filteredMethods = loginProvider !== ''
+                ? allSupportedMethods.filter((method) => normalizeAuthMethodProviderForMatch(method.provider) !== loginProvider)
+                : allSupportedMethods;
+            setSupportedMethods(filteredMethods);
+            setLinkedMethods(linkedResponse.linkedMethods ?? []);
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to load auth methods');
+            setSupportedMethods([]);
+            setLinkedMethods([]);
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setQueryLoading(false);
+        }
+    }, [getLinkedAuthMethods, getSupportedAuthMethods, requireConnectedWallet, whoami]);
+    const isLinked = useCallback((provider) => {
+        const normalizedProvider = normalizeAuthMethodProviderForMatch(provider);
+        return linkedMethods.some((method) => normalizeAuthMethodProviderForMatch(method.authProvider) === normalizedProvider);
+    }, [linkedMethods]);
+    const runOAuthPopupLink = useCallback(async (activeWallet, provider) => {
+        if (typeof window === 'undefined') {
+            throw new Error('OAuth linking requires a browser environment');
+        }
+        const { authUrl } = await activeWallet.initiateLinkAuth(provider);
+        const width = 500;
+        const height = 600;
+        const left = Math.round((window.screen.width - width) / 2);
+        const top = Math.round((window.screen.height - height) / 2);
+        const popup = window.open(authUrl, 'abstraxn-auth-link', `width=${width},height=${height},left=${left},top=${top},scrollbars=yes,resizable=yes`);
+        if (!popup) {
+            throw new Error('Popup blocked. Please allow popups for this site.');
+        }
+        const timeoutMs = 120000;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let closeCheckId = null;
+            let timeoutId = null;
+            const finalizeReject = (reason) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(new Error(reason));
+            };
+            const cleanup = () => {
+                window.removeEventListener('message', onMessage);
+                if (closeCheckId != null)
+                    clearInterval(closeCheckId);
+                if (timeoutId != null)
+                    clearTimeout(timeoutId);
+            };
+            const onMessage = (event) => {
+                if (event.origin !== window.location.origin)
+                    return;
+                if (event.source !== popup)
+                    return;
+                const data = event.data;
+                if (!data?.type)
+                    return;
+                const eventProvider = normalizeAuthMethodProviderForMatch(String(data.provider ?? ''));
+                const targetProvider = normalizeAuthMethodProviderForMatch(provider);
+                if (eventProvider !== targetProvider)
+                    return;
+                if (data.type === 'abstraxn-auth-link-error') {
+                    finalizeReject(normalizeAuthMethodErrorMessage(String(data.error ?? 'Failed to link auth method')));
+                    return;
+                }
+                if (data.type === 'abstraxn-auth-link-done') {
+                    if (!data.activityBody || data.activityBody.trim() === '') {
+                        finalizeReject('Invalid linking response');
+                        return;
+                    }
+                    settled = true;
+                    cleanup();
+                    activeWallet
+                        .submitLinkAuthStamped(provider, data.activityBody)
+                        .then(resolve)
+                        .catch((submitError) => {
+                        reject(toAuthMethodError(submitError, 'Failed to finalize auth method link'));
+                    });
+                }
+            };
+            window.addEventListener('message', onMessage);
+            closeCheckId = setInterval(() => {
+                if (popup.closed) {
+                    finalizeReject('Linking was cancelled');
+                }
+            }, 200);
+            timeoutId = setTimeout(() => {
+                finalizeReject('Linking timed out. Please try again.');
+            }, timeoutMs);
+        });
+    }, [wallet]);
+    const linkProvider = useCallback(async (provider) => {
+        const activeWallet = requireConnectedWallet();
+        const normalizedProvider = provider.toLowerCase();
+        if (!AUTH_METHOD_LINK_PROVIDER_ALLOWLIST.has(normalizedProvider)) {
+            throw new Error(`Unsupported provider for linking: ${provider}`);
+        }
+        setActionProvider(normalizedProvider);
+        setError(null);
+        try {
+            if (normalizedProvider === 'passkey') {
+                await activeWallet.linkPasskey();
+            }
+            else {
+                await runOAuthPopupLink(activeWallet, normalizedProvider);
+            }
+            await refreshAuthMethods({ force: true });
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to link auth method');
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setActionProvider(null);
+        }
+    }, [refreshAuthMethods, requireConnectedWallet, runOAuthPopupLink]);
+    const requestEmailLinkOtp = useCallback(async (email) => {
+        const activeWallet = requireConnectedWallet();
+        const trimmedEmail = email.trim();
+        if (!trimmedEmail) {
+            throw new Error('Email is required');
+        }
+        setActionProvider('email');
+        setError(null);
+        try {
+            if (requestOtpForEmailLink) {
+                return await requestOtpForEmailLink(trimmedEmail);
+            }
+            if (loginWithOTP) {
+                return await loginWithOTP(trimmedEmail);
+            }
+            // Fallback to core method directly if context methods are unavailable.
+            return await activeWallet.requestOtpForEmailLink(trimmedEmail);
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to send email verification code');
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setActionProvider(null);
+        }
+    }, [loginWithOTP, requestOtpForEmailLink, requireConnectedWallet]);
+    const confirmEmailLink = useCallback(async (otpId, otpCode) => {
+        const activeWallet = requireConnectedWallet();
+        const trimmedOtpId = otpId.trim();
+        const trimmedOtpCode = otpCode.trim();
+        if (!trimmedOtpId || !trimmedOtpCode) {
+            throw new Error('otpId and otpCode are required');
+        }
+        setActionProvider('email');
+        setError(null);
+        try {
+            await activeWallet.linkEmail(trimmedOtpId, trimmedOtpCode);
+            await refreshAuthMethods({ force: true });
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to link email');
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setActionProvider(null);
+        }
+    }, [refreshAuthMethods, requireConnectedWallet]);
+    const unlinkProvider = useCallback(async (provider) => {
+        const activeWallet = requireConnectedWallet();
+        const normalizedProvider = normalizeAuthMethodProviderForApi(provider);
+        if (!AUTH_METHOD_UNLINK_PROVIDER_ALLOWLIST.has(normalizedProvider)) {
+            throw new Error(`Unsupported provider for unlinking: ${provider}`);
+        }
+        setActionProvider(normalizedProvider);
+        setError(null);
+        try {
+            await activeWallet.unlinkAuthMethod(normalizedProvider);
+            await refreshAuthMethods({ force: true });
+        }
+        catch (err) {
+            const nextError = toAuthMethodError(err, 'Failed to unlink auth method');
+            setError(nextError.message);
+            throw nextError;
+        }
+        finally {
+            setActionProvider(null);
+        }
+    }, [refreshAuthMethods, requireConnectedWallet]);
+    return {
+        supportedMethods,
+        linkedMethods,
+        loading: queryLoading || actionProvider !== null,
+        actionProvider,
+        error,
+        refreshAuthMethods,
+        isLinked,
+        linkProvider,
+        requestEmailLinkOtp,
+        confirmEmailLink,
+        unlinkProvider,
+    };
+}
 /**
  * Hook to access external wallet functionality
  * Returns external wallet connection state and methods
@@ -1179,6 +1518,145 @@ export function useSignAndSendSolanaTxn(connection) {
     }, [connection, isConnected, whoami, signSolanaTransactionViaAPI, verifySignMfa]);
     return { signAndSendSolanaTxn, isConnected, solanaAddress: whoami?.solanaAddress ?? null };
 }
+function buildSolanaRelayerUrl(relayerBaseUrl, networkChainId, apiKey) {
+    const parsed = new URL(relayerBaseUrl);
+    const hasTxPath = /\/tx\/\d+\/?$/.test(parsed.pathname);
+    const hasChainOnlyPath = /\/\d+\/?$/.test(parsed.pathname);
+    if (!hasTxPath && !hasChainOnlyPath) {
+        const basePath = parsed.pathname.replace(/\/$/, "");
+        const withApiV1 = /\/api\/v1$/.test(basePath)
+            ? basePath
+            : `${basePath}/api/v1`;
+        parsed.pathname = `${withApiV1}/tx/${networkChainId}/`;
+    }
+    parsed.searchParams.set("apikey", apiKey);
+    return parsed.toString();
+}
+function hexToBase64SignedTransaction(signedHex) {
+    const hex = signedHex.startsWith('0x') ? signedHex.slice(2) : signedHex;
+    const bytes = new Uint8Array(hex.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16)) ?? []);
+    if (typeof btoa === 'function') {
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++)
+            binary += String.fromCharCode(bytes[i]);
+        return btoa(binary);
+    }
+    return Buffer.from(bytes).toString('base64');
+}
+export function useSolanaGasless() {
+    const { isConnected, whoami, solanaConnection, signSolanaTransactionViaAPI, verifySignMfa, solanaGaslessConfig, } = useAbstraxnWallet();
+    const providerConnection = solanaConnection?.connection ?? null;
+    const resolvedConfig = useMemo(() => {
+        if (!solanaGaslessConfig?.enabled)
+            return null;
+        const relayerBaseUrl = solanaGaslessConfig.relayerBaseUrl?.trim();
+        const apiKey = solanaGaslessConfig.apiKey?.trim();
+        const networkChainId = solanaGaslessConfig.networkChainId;
+        if (!relayerBaseUrl || !apiKey || !networkChainId)
+            return null;
+        const base = relayerBaseUrl.replace(/\/$/, '');
+        const relayerUrl = buildSolanaRelayerUrl(base, networkChainId, apiKey);
+        return {
+            enabled: true,
+            relayerBaseUrl: base,
+            apiKey,
+            networkChainId,
+            defaultPollMs: solanaGaslessConfig.defaultPollMs,
+            defaultTimeoutMs: solanaGaslessConfig.defaultTimeoutMs,
+            relayerUrl,
+        };
+    }, [solanaGaslessConfig]);
+    const relayerClient = useMemo(() => {
+        if (!resolvedConfig)
+            return null;
+        return new SolanaRelayer({
+            relayerUrl: resolvedConfig.relayerUrl,
+            defaultPollMs: resolvedConfig.defaultPollMs,
+            defaultTimeoutMs: resolvedConfig.defaultTimeoutMs,
+        });
+    }, [resolvedConfig]);
+    const ensureReady = useCallback(() => {
+        if (!isConnected)
+            throw new Error('Wallet is not connected');
+        if (!resolvedConfig) {
+            throw new Error('Solana gasless is not configured. Set config.solanaGasless with enabled, relayerBaseUrl, apiKey and networkChainId.');
+        }
+        if (!relayerClient)
+            throw new Error('Failed to initialize Solana relayer client');
+        if (!signSolanaTransactionViaAPI) {
+            throw new Error('Solana transaction signing is not supported by this wallet');
+        }
+        const sender = whoami?.solanaAddress ?? null;
+        if (!sender)
+            throw new Error('Solana address is required for gasless flow');
+        return { sender };
+    }, [isConnected, relayerClient, resolvedConfig, signSolanaTransactionViaAPI, whoami]);
+    const buildGaslessTx = useCallback(async (params) => {
+        const { sender } = ensureReady();
+        const connection = params.connection ?? providerConnection;
+        if (!connection)
+            throw new Error('Solana connection is required');
+        const { connection: _connection, sender: _sender, ...rest } = params;
+        return await relayerClient.buildTx({
+            connection,
+            sender: _sender ?? sender,
+            ...rest,
+        });
+    }, [ensureReady, providerConnection, relayerClient]);
+    const signGaslessTx = useCallback(async (params) => {
+        const { sender } = ensureReady();
+        const unsignedBytes = params.transaction.serialize({ requireAllSignatures: false });
+        const unsignedHex = Array.from(unsignedBytes)
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+        const signWith = params.sender ?? sender;
+        const { signedTransaction } = await runWithSignStepUpRetry(() => signSolanaTransactionViaAPI(unsignedHex, signWith), verifySignMfa);
+        return {
+            signedTransactionHex: signedTransaction,
+            signedTransactionBase64: hexToBase64SignedTransaction(signedTransaction),
+        };
+    }, [ensureReady, signSolanaTransactionViaAPI, verifySignMfa]);
+    const sendGaslessTx = useCallback(async (params) => {
+        ensureReady();
+        return await relayerClient.sendTx({
+            signedTransaction: params.signedTransactionBase64,
+            lastValidBlockHeight: params.lastValidBlockHeight,
+        });
+    }, [ensureReady, relayerClient]);
+    const getGaslessTxStatus = useCallback(async (txnId) => {
+        ensureReady();
+        return await relayerClient.getTxStatus({ txnId });
+    }, [ensureReady, relayerClient]);
+    return {
+        isEnabled: !!resolvedConfig,
+        config: resolvedConfig,
+        relayerClient,
+        buildGaslessTx,
+        signGaslessTx,
+        sendGaslessTx,
+        getGaslessTxStatus,
+    };
+}
+export function useSignAndSendSolanaGaslessTxn() {
+    const { buildGaslessTx, signGaslessTx, sendGaslessTx } = useSolanaGasless();
+    const signAndSendGaslessTx = useCallback(async (params) => {
+        const built = await buildGaslessTx(params);
+        const signed = await signGaslessTx({ transaction: built.tx, sender: params.sender });
+        const relay = await sendGaslessTx({
+            signedTransactionBase64: signed.signedTransactionBase64,
+            lastValidBlockHeight: built.lastValidBlockHeight,
+        });
+        return {
+            txnId: relay.txnId,
+            status: relay.status,
+            preview: built.preview,
+            signedTransactionHex: signed.signedTransactionHex,
+            signedTransactionBase64: signed.signedTransactionBase64,
+            lastValidBlockHeight: built.lastValidBlockHeight,
+        };
+    }, [buildGaslessTx, sendGaslessTx, signGaslessTx]);
+    return { signAndSendGaslessTx };
+}
 /**
  * Hook to wait for Solana transaction confirmation.
  */