@txwallet/graz-connector 0.1.0

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@txwallet/graz-connector",
+  "version": "0.1.0",
+  "description": "Thin-slice Graz compatibility connector for TX Wallet.",
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./react": {
+      "types": "./react.d.ts",
+      "default": "./react.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "react.js",
+    "react.d.ts",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "tx-wallet",
+    "graz",
+    "cosmos",
+    "wallet-connector"
+  ]
+}

package/react.d.ts

@@ -0,0 +1,47 @@
+import type {
+  TxWalletGrazConnector,
+  TxWalletGrazConnectorError,
+  TxWalletGrazConnectedAccount,
+  TxWalletGrazAccount,
+  TxWalletGrazSignResult,
+  TxWalletGrazTransactionResult,
+  TxWalletGrazAuthHandlerOptions,
+} from './index';
+
+export interface UseTxWalletGrazConnectorResult {
+  connector: TxWalletGrazConnector;
+  status: TxWalletGrazConnector['state'];
+  account: TxWalletGrazAccount | null;
+  error: TxWalletGrazConnectorError | null;
+  isIdle: boolean;
+  isConnecting: boolean;
+  isConnected: boolean;
+  isSigning: boolean;
+  isRequesting: boolean;
+  connect(input: {
+    chainId: string;
+    appId: string;
+    callbackUrl: string;
+    statement?: string;
+  }): Promise<TxWalletGrazConnectedAccount | undefined>;
+  signAdr36(input: {
+    appId: string;
+    requestId?: string;
+    callbackUrl: string;
+    challenge?: Record<string, unknown>;
+  }): Promise<TxWalletGrazSignResult | undefined>;
+  requestTransaction(input: {
+    appId: string;
+    requestId?: string;
+    callbackUrl: string;
+    chainId?: string;
+    body?: Record<string, unknown>;
+    statusUrl?: string;
+    fallbackUrl?: string;
+  }): Promise<TxWalletGrazTransactionResult | undefined>;
+  disconnect(): Promise<void>;
+}
+
+export function useTxWalletGrazConnector(
+  connectorOrOptions?: TxWalletGrazConnector | (TxWalletGrazAuthHandlerOptions & { initialChainId?: string }),
+): UseTxWalletGrazConnectorResult;

package/react.js

@@ -0,0 +1,106 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { createTxWalletGrazAuthConnector } from './index.js';
+
+const isConnectorInstance = (value) => (
+  Boolean(value)
+  && typeof value === 'object'
+  && typeof value.connect === 'function'
+  && typeof value.on === 'function'
+  && typeof value.getState === 'function'
+);
+
+const readAccount = (connector) => (
+  connector.accountAddress
+    ? { accountAddress: connector.accountAddress, chainId: connector.chainId }
+    : null
+);
+
+/**
+ * React hook that wraps a TX Wallet Graz connector with graz-style ergonomics:
+ * reactive `status`/`account`/`error` plus fire-and-forget-safe actions.
+ *
+ * Pass an existing connector instance, or auth-handler options to build one
+ * (an auth-backed connector is created once on mount). The action methods never
+ * throw — failures surface through `error`/`status`; use the returned `connector`
+ * directly if you need the raw throwing/awaitable calls.
+ */
+export function useTxWalletGrazConnector(connectorOrOptions = {}) {
+  const connectorRef = useRef(null);
+  if (connectorRef.current === null) {
+    connectorRef.current = isConnectorInstance(connectorOrOptions)
+      ? connectorOrOptions
+      : createTxWalletGrazAuthConnector(connectorOrOptions);
+  }
+  const connector = connectorRef.current;
+
+  const [status, setStatus] = useState(() => connector.getState());
+  const [account, setAccount] = useState(() => readAccount(connector));
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    const offState = connector.on('state', (next) => setStatus(next));
+    const offConnected = connector.on('connected', (detail) => {
+      setAccount({ accountAddress: detail.accountAddress, chainId: detail.chainId });
+      setError(null);
+    });
+    const offDisconnected = connector.on('disconnected', () => setAccount(null));
+    const offError = connector.on('error', (normalizedError) => setError(normalizedError));
+
+    // Re-sync in case the connector changed state between render and subscription.
+    setStatus(connector.getState());
+    setAccount(readAccount(connector));
+
+    return () => {
+      offState();
+      offConnected();
+      offDisconnected();
+      offError();
+    };
+  }, [connector]);
+
+  const connect = useCallback(async (input) => {
+    setError(null);
+    try {
+      return await connector.connect(input);
+    } catch {
+      // Normalized error is surfaced via the 'error' event -> error state.
+      return undefined;
+    }
+  }, [connector]);
+
+  const signAdr36 = useCallback(async (input) => {
+    setError(null);
+    try {
+      return await connector.signAdr36(input);
+    } catch {
+      return undefined;
+    }
+  }, [connector]);
+
+  const requestTransaction = useCallback(async (input) => {
+    setError(null);
+    try {
+      return await connector.requestTransaction(input);
+    } catch {
+      return undefined;
+    }
+  }, [connector]);
+
+  const disconnect = useCallback(() => connector.disconnect(), [connector]);
+
+  return {
+    connector,
+    status,
+    account,
+    error,
+    isIdle: status === 'idle',
+    isConnecting: status === 'connecting',
+    isConnected: status === 'connected',
+    isSigning: status === 'signing',
+    isRequesting: status === 'requesting',
+    connect,
+    signAdr36,
+    requestTransaction,
+    disconnect,
+  };
+}