@abstraxn/signer-react 1.0.16 → 2.0.1

package/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.1] - 2026-03-03
+
+### Fixed
+
+- **Abstraxn wallet balance polling** – Removed the 10-second interval that refetched the connected Abstraxn wallet’s native balance from the chain RPC. Balance is still fetched once when the user connects (email, Google, passkey, Twitter, Discord) or when address/chain changes, but no longer triggers an RPC call every 10 seconds while the session is active.
+
+## [2.0.0] - 2026-03-02
+
+### Added
+
+- **First-class Solana support (embedded wallets)** – New Turnkey-backed Solana hooks to prepare, sign, and send Solana transactions using the same embedded wallet that users get from email/social/passkey login:
+  - `useSolanaConnection(rpcUrl, commitment?)` – creates a `Connection` for Solana RPC.
+  - `useSolanaPublicKey()` – reads `whoami.solanaAddress` and exposes `{ solanaAddress, isConnected }`.
+  - `usePrepareSolanaTxn(connection)` – returns `prepareSolanaTransfer({ fromPubkey, toPubkey, amountInSol })` for native SOL transfers.
+  - `useSignSolanaTxn(connection)` / `useSignAndSendSolanaTxn(connection)` – sign (and optionally send) Solana transactions via Turnkey using `TRANSACTION_TYPE_SOLANA`.
+  - `useWaitForSolanaConfirmation(connection)` – waits for Solana transaction confirmation.
+- **Solana program (contract) transactions** – High-level APIs for program calls without exposing `@solana/web3.js` to app code:
+  - `SolanaAccountMetaInput` / `SolanaInstructionDataInput` types to describe accounts and encoded instruction data.
+  - `usePrepareSolanaProgramTxn(connection)` – builds a `Transaction` from `{ feePayer, programId, accounts, data }`.
+  - `useSolanaProgramTransaction(connection)` – `sendProgramTransaction(...)` helper that prepares, signs, and broadcasts a Solana program transaction in one call and returns `{ signature, unsignedTransaction, signedTransaction }` (hex).
+- **Docs** – New `SOLANA.md` with end-to-end examples for native SOL transfers and program calls, and README updates pointing to the new Solana hooks.
+
+### Changed
+
+- **WalletModal send flow** – `useSendTransaction` inside the Wallet modal now supports Solana chains for native transfers by delegating to the new Solana hooks instead of throwing `"Solana transactions are not yet supported"`. EVM behavior is unchanged.
+- **Turnkey integration (internal)** – Solana unsigned transactions are now serialized and sent to Turnkey as hex, and the signed hex is converted back to bytes for `sendRawTransaction`. This matches Turnkey’s `TRANSACTION_TYPE_SOLANA` expectations and prevents decode errors.
+
 ## [1.0.16] - 2026-02-23
 
 ### Fixed

package/README.md

@@ -98,11 +98,107 @@ function HookConnectButton() {
 
 - `useAbstraxnWallet()` - Main wallet hook
 - `useIsConnected()` - Check connection status
-- `useAddress()` - Get wallet address
-- `useWhoami()` - Get user information
-- `useExternalWalletInfo()` - External wallet information
-- `usePrepareTransaction()` - Prepare and sign transactions
-- `useExportWallet()` - Export wallet
+- `useAddress()` - Get wallet address (EVM)
+- `useWhoami()` - Get user information (includes `solanaAddress` when available)
+- `useExternalWalletInfo()` - External wallet information (EVM)
+- `useExportWallet()` - Export wallet (EVM or Solana, based on current chain)
+- `usePublicClient()` / `usePrepareRawTxn()` / `useSignTxn()` / `useSignAndSendTxn()` / `useWaitForTxnReceipt()` - EVM transaction flow (prepare → sign → send → confirm)
+- `useSolanaConnection()` / `useSolanaPublicKey()` / `usePrepareSolanaTxn()` / `useSignSolanaTxn()` / `useSignAndSendSolanaTxn()` / `useWaitForSolanaConfirmation()` - Solana transaction flow (prepare → sign → send → confirm)
+
+### Example: EVM → Solana flow after social/email login
+
+```tsx
+import {
+  useAbstraxnWallet,
+  usePublicClient,
+  usePrepareRawTxn,
+  useEstimateGas,
+  useGetGasPrice,
+  useSignAndSendTxn,
+  useWaitForTxnReceipt,
+  useSolanaConnection,
+  useSolanaPublicKey,
+  usePrepareSolanaTxn,
+  useSignAndSendSolanaTxn,
+  useWaitForSolanaConfirmation,
+} from '@abstraxn/signer-react';
+import { polygonAmoy } from 'viem/chains';
+
+function CrossChainExample() {
+  const { isConnected } = useAbstraxnWallet();
+
+  // EVM clients & hooks
+  const { publicClient } = usePublicClient(
+    polygonAmoy,
+    'https://rpc-amoy.polygon.technology'
+  );
+  const { prepareRawTxn } = usePrepareRawTxn(publicClient);
+  const { estimateGas } = useEstimateGas(publicClient);
+  const { getGasPrice } = useGetGasPrice(publicClient);
+  const { signAndSendTxn } = useSignAndSendTxn(publicClient);
+  const { waitForTxnReceipt } = useWaitForTxnReceipt(publicClient);
+
+  // Solana clients & hooks
+  const { connection } = useSolanaConnection('https://api.devnet.solana.com');
+  const { solanaAddress } = useSolanaPublicKey();
+  const { prepareSolanaTransfer } = usePrepareSolanaTxn(connection);
+  const { signAndSendSolanaTxn } = useSignAndSendSolanaTxn(connection);
+  const { waitForSolanaConfirmation } = useWaitForSolanaConfirmation(connection);
+
+  const handleCrossChain = async () => {
+    if (!isConnected) throw new Error('Please login first');
+
+    // 1) EVM tx (e.g. on Polygon Amoy)
+    const from = '0x...'; // current EVM address
+    const rawTx = await prepareRawTxn({
+      from,
+      to: '0x...',
+      value: '0.001',
+    });
+    const { gasLimit } = await estimateGas({
+      account: from,
+      to: rawTx.to,
+      data: rawTx.data,
+      value: rawTx.value,
+    });
+    const fees = await getGasPrice();
+
+    const evmResult = await signAndSendTxn({
+      from,
+      ...rawTx,
+      gas: {
+        gasLimit,
+        maxFeePerGas: fees.maxFeePerGas!,
+        maxPriorityFeePerGas: fees.maxPriorityFeePerGas!,
+      },
+    });
+
+    await waitForTxnReceipt({ hash: evmResult.hash, confirmations: 1 });
+
+    // 2) After EVM confirmation, send SOL
+    if (!solanaAddress) throw new Error('Solana wallet not provisioned');
+
+    const { transaction } = await prepareSolanaTransfer({
+      fromPubkey: solanaAddress,
+      toPubkey: 'TargetSolanaAddressHere',
+      amountInSol: 0.01,
+    });
+
+    const solanaResult = await signAndSendSolanaTxn({
+      transaction,
+      fromPubkey: solanaAddress,
+    });
+
+    await waitForSolanaConfirmation({ signature: solanaResult.signature });
+  };
+
+  return (
+    <button onClick={handleCrossChain}>
+      Run EVM → Solana Flow
+    </button>
+  );
+}
+```
 
 ## 🔗 Related Packages
 

package/dist/src/components/AbstraxnProvider/AbstraxnProviderInner.js

@@ -1725,6 +1725,28 @@ export function AbstraxnProviderInner({ config, children, base, wagmi, }) {
             setLoading(false);
         }
     }, []);
+    // Sign Solana transaction via API (returns signed transaction)
+    const signSolanaTransactionViaAPI = useCallback(async (unsignedTransaction, fromAddress) => {
+        if (!walletRef.current)
+            throw new Error("Wallet not initialized");
+        setLoading(true);
+        setError(null);
+        try {
+            const walletAny = walletRef.current;
+            if (typeof walletAny.signSolanaTransactionViaAPI !== "function") {
+                throw new Error("Solana transaction signing is not supported by this wallet");
+            }
+            return await walletAny.signSolanaTransactionViaAPI(unsignedTransaction, fromAddress);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error("Failed to sign Solana transaction");
+            setError(error);
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
     // Sign typed data / raw payload via API (same flow as signTransactionViaAPI, payload: from, unsignedTransaction, encoding, hashFunction)
     const signTypedTxViaAPI = useCallback(async (fromAddress, unsignedTransaction, encoding, hashFunction) => {
         if (!walletRef.current)
@@ -2687,9 +2709,6 @@ export function AbstraxnProviderInner({ config, children, base, wagmi, }) {
             }
         };
         fetchBalance();
-        // Refetch balance every 10 seconds
-        const interval = setInterval(fetchBalance, 10000);
-        return () => clearInterval(interval);
     }, [address, currentChainId, isExternalWalletConnected]);
     // Compute available chains from config - supports both legacy and new format
     const availableChains = useMemo(() => {
@@ -2855,6 +2874,7 @@ export function AbstraxnProviderInner({ config, children, base, wagmi, }) {
         signTransaction,
         sendTransaction,
         signTransactionViaAPI,
+        signSolanaTransactionViaAPI,
         signTypedTxViaAPI,
         signAndSendTransaction,
         loginWithOTP,