@meshconnect/uwc-react 0.6.11 → 0.7.0-snapshot.6b75329

package/README.md

@@ -199,6 +199,34 @@ function WalletList() {
 }
 ```
 
+#### useSignSolanaTransaction
+
+Sign a Solana transaction **without broadcasting it** — for fee-payer relay flows where a relay (e.g. your backend) pays the network fee and submits the transaction. Raw bytes in, signed bytes out, so callers don't need `@solana/web3.js`:
+
+```tsx
+import { useSignSolanaTransaction } from '@meshconnect/uwc-react'
+
+function SignButton({ unsignedTx }: { unsignedTx: Uint8Array }) {
+  const { signSolanaTransaction, isLoading, error } = useSignSolanaTransaction()
+
+  const onSign = async () => {
+    const signedTx = await signSolanaTransaction(unsignedTx)
+    // Hand signedTx to your relay to broadcast — UWC never sends it.
+  }
+
+  return (
+    <div>
+      <button onClick={onSign} disabled={isLoading}>
+        {isLoading ? 'Signing...' : 'Sign Transaction'}
+      </button>
+      {error && <p>{error.message}</p>}
+    </div>
+  )
+}
+```
+
+Works with injected wallets, WalletConnect, and through the iframe bridge.
+
 ## API Reference
 
 ### ConnectionProvider
@@ -230,4 +258,7 @@ Returns the current session state.
 Returns the list of available wallets.
 
 #### useNetworks()
-Returns the list of available networks.
+Returns the list of available networks.
+
+#### useSignSolanaTransaction()
+Returns a sign-only `signSolanaTransaction(bytes: Uint8Array) => Promise<Uint8Array>` for Solana fee-payer relay flows, plus `isLoading` and `error` state. Never broadcasts — the relay owns submission.

package/dist/hooks/index.d.ts

@@ -9,4 +9,5 @@ export * from './useSignMessage';
 export * from './useTransaction';
 export * from './useWalletCapabilities';
 export * from './useDetectedWallets';
+export * from './useSignSolanaTransaction';
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA"}

package/dist/hooks/index.js

@@ -9,4 +9,5 @@ export * from './useSignMessage';
 export * from './useTransaction';
 export * from './useWalletCapabilities';
 export * from './useDetectedWallets';
+export * from './useSignSolanaTransaction';
 //# sourceMappingURL=index.js.map

package/dist/hooks/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA"}

package/dist/hooks/useSignSolanaTransaction.d.ts

@@ -0,0 +1,3 @@
+import type { UseSignSolanaTransactionReturn } from '@meshconnect/uwc-types';
+export declare function useSignSolanaTransaction(): UseSignSolanaTransactionReturn;
+//# sourceMappingURL=useSignSolanaTransaction.d.ts.map

package/dist/hooks/useSignSolanaTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignSolanaTransaction.d.ts","sourceRoot":"","sources":["../../src/hooks/useSignSolanaTransaction.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,8BAA8B,EAE/B,MAAM,wBAAwB,CAAA;AAE/B,wBAAgB,wBAAwB,IAAI,8BAA8B,CAuCzE"}

package/dist/hooks/useSignSolanaTransaction.js

@@ -0,0 +1,34 @@
+import { useContext, useCallback, useState } from 'react';
+import { ConnectionContext } from '../providers/ConnectionProvider';
+export function useSignSolanaTransaction() {
+    const context = useContext(ConnectionContext);
+    if (!context) {
+        throw new Error('useSignSolanaTransaction must be used within a ConnectionProvider');
+    }
+    const { connector, session } = context;
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState();
+    const signSolanaTransaction = useCallback(async (serializedTx) => {
+        if (!session.activeAddress) {
+            throw new Error('No wallet connected');
+        }
+        if (!serializedTx?.length) {
+            throw new Error('Transaction bytes are required');
+        }
+        setIsLoading(true);
+        setError(undefined);
+        try {
+            return await connector.signSolanaTransaction(serializedTx);
+        }
+        catch (err) {
+            const walletError = err;
+            setError(walletError);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [connector, session.activeAddress]);
+    return { signSolanaTransaction, isLoading, error };
+}
+//# sourceMappingURL=useSignSolanaTransaction.js.map

package/dist/hooks/useSignSolanaTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignSolanaTransaction.js","sourceRoot":"","sources":["../../src/hooks/useSignSolanaTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AAMnE,MAAM,UAAU,wBAAwB;IACtC,MAAM,OAAO,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAA;IAE7C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,mEAAmE,CACpE,CAAA;IACH,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,OAAO,CAAA;IACtC,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IACjD,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,EAA2B,CAAA;IAE7D,MAAM,qBAAqB,GAAG,WAAW,CACvC,KAAK,EAAE,YAAwB,EAAuB,EAAE;QACtD,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAA;QACxC,CAAC;QAED,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAA;QACnD,CAAC;QAED,YAAY,CAAC,IAAI,CAAC,CAAA;QAClB,QAAQ,CAAC,SAAS,CAAC,CAAA;QACnB,IAAI,CAAC;YACH,OAAO,MAAM,SAAS,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAA;QAC5D,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,WAAW,GAAG,GAAkB,CAAA;YACtC,QAAQ,CAAC,WAAW,CAAC,CAAA;YACrB,MAAM,GAAG,CAAA;QACX,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,KAAK,CAAC,CAAA;QACrB,CAAC;IACH,CAAC,EACD,CAAC,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,CACnC,CAAA;IAED,OAAO,EAAE,qBAAqB,EAAE,SAAS,EAAE,KAAK,EAAE,CAAA;AACpD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshconnect/uwc-react",
-  "version": "0.6.11",
+  "version": "0.7.0-snapshot.6b75329",
   "description": "React hooks and components for Universal Wallet Connector",
   "type": "module",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
     "src"
   ],
   "dependencies": {
-    "@meshconnect/uwc-core": "0.7.11",
-    "@meshconnect/uwc-types": "0.13.0"
+    "@meshconnect/uwc-core": "0.8.0-snapshot.6b75329",
+    "@meshconnect/uwc-types": "0.14.0-snapshot.6b75329"
   },
   "peerDependencies": {
     "react": "^18.0.0",

package/src/hooks/index.ts

@@ -9,3 +9,4 @@ export * from './useSignMessage'
 export * from './useTransaction'
 export * from './useWalletCapabilities'
 export * from './useDetectedWallets'
+export * from './useSignSolanaTransaction'

package/src/hooks/useSignSolanaTransaction.test.tsx

@@ -0,0 +1,297 @@
+import React, { act } from 'react'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { createRoot } from 'react-dom/client'
+import { ConnectionContext } from '../providers/ConnectionProvider'
+import { useSignSolanaTransaction } from './useSignSolanaTransaction'
+import type { UseSignSolanaTransactionReturn } from '@meshconnect/uwc-types'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Minimal stub that satisfies ConnectionContextValue's connector shape. */
+function makeConnector(
+  signSolanaTransaction: (tx: Uint8Array) => Promise<Uint8Array>
+) {
+  return {
+    signSolanaTransaction,
+    // other connector methods are not exercised by this hook
+    getSession: () => ({ isConnected: false }),
+    isReady: () => true,
+    subscribe: () => () => {},
+    getWallets: () => [],
+    getNetworks: () => []
+  }
+}
+
+/**
+ * Minimal context value that wraps a connector stub. Pass `{ activeAddress }`
+ * as an object (not a bare arg) so an explicit `undefined` survives — a default
+ * parameter would otherwise replace `undefined` with the connected address.
+ */
+function makeContextValue(
+  connector: ReturnType<typeof makeConnector>,
+  { activeAddress }: { activeAddress: string | undefined } = {
+    activeAddress: 'SoLanaTestAddr1111111111111111111111111111'
+  }
+) {
+  return {
+    connector,
+    session: {
+      isConnected: activeAddress !== undefined,
+      walletId: undefined,
+      networkId: undefined,
+      activeAddress
+    },
+    wallets: [],
+    networks: [],
+    isReady: true
+  }
+}
+
+/**
+ * Renders `useSignSolanaTransaction` inside a component that exposes its
+ * return value via a captured ref. Returns the ref and cleanup helpers.
+ *
+ * Pattern mirrors ConnectionProvider.singleton.test.tsx: createRoot + act,
+ * no @testing-library/react (not installed in this package).
+ */
+function renderHookInContext(
+  contextValue: ReturnType<typeof makeContextValue>
+) {
+  const captured: { current: UseSignSolanaTransactionReturn | null } = {
+    current: null
+  }
+
+  function Capture() {
+    captured.current = useSignSolanaTransaction()
+    return null
+  }
+
+  const container = document.createElement('div')
+  document.body.appendChild(container)
+  const root = createRoot(container)
+
+  async function render() {
+    await act(async () => {
+      root.render(
+        <ConnectionContext.Provider value={contextValue as never}>
+          <Capture />
+        </ConnectionContext.Provider>
+      )
+    })
+  }
+
+  async function unmount() {
+    await act(async () => {
+      root.unmount()
+    })
+    document.body.removeChild(container)
+  }
+
+  return { captured, render, unmount }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('useSignSolanaTransaction', () => {
+  let container: HTMLDivElement
+  let root: ReturnType<typeof createRoot>
+
+  beforeEach(() => {
+    container = document.createElement('div')
+    document.body.appendChild(container)
+    root = createRoot(container)
+  })
+
+  afterEach(async () => {
+    await act(async () => {
+      root.unmount()
+    })
+    if (document.body.contains(container)) {
+      document.body.removeChild(container)
+    }
+  })
+
+  // (a) throws when used outside ConnectionProvider
+  it('throws when rendered outside ConnectionProvider', () => {
+    function BareHook() {
+      useSignSolanaTransaction()
+      return null
+    }
+
+    expect(() => {
+      // Synchronous render — React will throw during render, caught here.
+      // Suppress the React error-boundary noise this logs on the way out.
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+      try {
+        act(() => {
+          root.render(<BareHook />)
+        })
+      } finally {
+        errorSpy.mockRestore()
+      }
+    }).toThrowError(
+      'useSignSolanaTransaction must be used within a ConnectionProvider'
+    )
+  })
+
+  // (b) returns the Uint8Array from connector.signSolanaTransaction on success
+  it('returns the signed bytes from connector on success', async () => {
+    const signedBytes = new Uint8Array([1, 2, 3, 4])
+    const mockSign = vi.fn().mockResolvedValue(signedBytes)
+    const ctxValue = makeContextValue(makeConnector(mockSign))
+    const { captured, render, unmount } = renderHookInContext(ctxValue)
+
+    await render()
+    expect(captured.current).not.toBeNull()
+
+    const input = new Uint8Array([9, 8, 7])
+    let result: Uint8Array | undefined
+
+    await act(async () => {
+      result = await captured.current!.signSolanaTransaction(input)
+    })
+
+    expect(mockSign).toHaveBeenCalledOnce()
+    expect(mockSign).toHaveBeenCalledWith(input)
+    expect(result).toBe(signedBytes)
+    await unmount()
+  })
+
+  // (c) sets error state and re-throws when connector.signSolanaTransaction rejects
+  it('sets error state and re-throws when connector rejects', async () => {
+    const walletError = { code: 4001, message: 'User rejected' }
+    const mockSign = vi.fn().mockRejectedValue(walletError)
+    const ctxValue = makeContextValue(makeConnector(mockSign))
+    const { captured, render, unmount } = renderHookInContext(ctxValue)
+
+    await render()
+
+    let thrownError: unknown
+    await act(async () => {
+      try {
+        await captured.current!.signSolanaTransaction(new Uint8Array([1]))
+      } catch (err) {
+        thrownError = err
+      }
+    })
+
+    expect(thrownError).toBe(walletError)
+    expect(captured.current!.error).toBe(walletError)
+    await unmount()
+  })
+
+  // (d) isLoading is true during the call and false after — success path
+  it('sets isLoading=true during call and false after success', async () => {
+    let resolveSign!: (v: Uint8Array) => void
+    const pendingSign = new Promise<Uint8Array>(res => {
+      resolveSign = res
+    })
+    const mockSign = vi.fn().mockReturnValue(pendingSign)
+    const ctxValue = makeContextValue(makeConnector(mockSign))
+    const { captured, render, unmount } = renderHookInContext(ctxValue)
+
+    await render()
+
+    // Start the async call but don't await it yet — capture loading mid-flight
+    let callPromise: Promise<Uint8Array>
+    await act(async () => {
+      callPromise = captured.current!.signSolanaTransaction(new Uint8Array([5]))
+    })
+
+    // At this point the hook has flipped isLoading=true (setIsLoading runs before the await)
+    expect(captured.current!.isLoading).toBe(true)
+
+    // Settle the promise
+    await act(async () => {
+      resolveSign(new Uint8Array([99]))
+      await callPromise!
+    })
+
+    expect(captured.current!.isLoading).toBe(false)
+    await unmount()
+  })
+
+  // (d) isLoading is false after failure path
+  it('sets isLoading=false after connector rejects', async () => {
+    let rejectSign!: (err: unknown) => void
+    const pendingSign = new Promise<Uint8Array>((_, rej) => {
+      rejectSign = rej
+    })
+    const mockSign = vi.fn().mockReturnValue(pendingSign)
+    const ctxValue = makeContextValue(makeConnector(mockSign))
+    const { captured, render, unmount } = renderHookInContext(ctxValue)
+
+    await render()
+
+    let callPromise: Promise<Uint8Array>
+    await act(async () => {
+      callPromise = captured.current!.signSolanaTransaction(new Uint8Array([6]))
+    })
+
+    expect(captured.current!.isLoading).toBe(true)
+
+    await act(async () => {
+      rejectSign({ code: 4001, message: 'cancelled' })
+      try {
+        await callPromise!
+      } catch {
+        // expected
+      }
+    })
+
+    expect(captured.current!.isLoading).toBe(false)
+    await unmount()
+  })
+
+  // (e) throws "No wallet connected" before touching the connector when no active address
+  it('throws "No wallet connected" when there is no active address', async () => {
+    const mockSign = vi.fn()
+    const ctxValue = makeContextValue(makeConnector(mockSign), {
+      activeAddress: undefined
+    })
+    const { captured, render, unmount } = renderHookInContext(ctxValue)
+
+    await render()
+
+    let thrownError: unknown
+    await act(async () => {
+      try {
+        await captured.current!.signSolanaTransaction(new Uint8Array([1]))
+      } catch (err) {
+        thrownError = err
+      }
+    })
+
+    expect((thrownError as Error).message).toBe('No wallet connected')
+    expect(mockSign).not.toHaveBeenCalled()
+    await unmount()
+  })
+
+  // (f) rejects empty input before touching the connector
+  it('throws "Transaction bytes are required" for empty bytes', async () => {
+    const mockSign = vi.fn()
+    const ctxValue = makeContextValue(makeConnector(mockSign))
+    const { captured, render, unmount } = renderHookInContext(ctxValue)
+
+    await render()
+
+    let thrownError: unknown
+    await act(async () => {
+      try {
+        await captured.current!.signSolanaTransaction(new Uint8Array(0))
+      } catch (err) {
+        thrownError = err
+      }
+    })
+
+    expect((thrownError as Error).message).toBe(
+      'Transaction bytes are required'
+    )
+    expect(mockSign).not.toHaveBeenCalled()
+    await unmount()
+  })
+})

package/src/hooks/useSignSolanaTransaction.ts

@@ -0,0 +1,47 @@
+import { useContext, useCallback, useState } from 'react'
+import { ConnectionContext } from '../providers/ConnectionProvider'
+import type {
+  UseSignSolanaTransactionReturn,
+  WalletError
+} from '@meshconnect/uwc-types'
+
+export function useSignSolanaTransaction(): UseSignSolanaTransactionReturn {
+  const context = useContext(ConnectionContext)
+
+  if (!context) {
+    throw new Error(
+      'useSignSolanaTransaction must be used within a ConnectionProvider'
+    )
+  }
+
+  const { connector, session } = context
+  const [isLoading, setIsLoading] = useState(false)
+  const [error, setError] = useState<WalletError | undefined>()
+
+  const signSolanaTransaction = useCallback(
+    async (serializedTx: Uint8Array): Promise<Uint8Array> => {
+      if (!session.activeAddress) {
+        throw new Error('No wallet connected')
+      }
+
+      if (!serializedTx?.length) {
+        throw new Error('Transaction bytes are required')
+      }
+
+      setIsLoading(true)
+      setError(undefined)
+      try {
+        return await connector.signSolanaTransaction(serializedTx)
+      } catch (err) {
+        const walletError = err as WalletError
+        setError(walletError)
+        throw err
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [connector, session.activeAddress]
+  )
+
+  return { signSolanaTransaction, isLoading, error }
+}