clutch-hub-sdk-js 4.2.1 → 4.4.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [4.4.0](https://github.com/clutchprotocol/clutch-hub/compare/v4.3.0...v4.4.0) (2026-10-06)
+
+
+### Features
+
+* **sdk:** sign with TronLink (signMessageV2, TIP-191), and the demo app connects it ([#32](https://github.com/clutchprotocol/clutch-hub/issues/32)) ([57fdd06](https://github.com/clutchprotocol/clutch-hub/commit/57fdd06297ff0b1f434d4b27d4941777772baeec))
+
+## [4.3.0](https://github.com/clutchprotocol/clutch-hub/compare/v4.2.1...v4.3.0) (2026-10-06)
+
+
+### Features
+
+* **sdk:** sign with a wallet (MetaMask, Trust Wallet); the demo app holds no key ([#30](https://github.com/clutchprotocol/clutch-hub/issues/30)) ([db41df0](https://github.com/clutchprotocol/clutch-hub/commit/db41df077f19340afe72fac314f36e7773486f58))
+
 ## [4.2.1](https://github.com/clutchprotocol/clutch-hub-sdk-js/compare/v4.2.0...v4.2.1) (2026-09-18)
 
 

package/README.md

@@ -41,9 +41,26 @@ await sdk.submitTransaction(signed.rawTransaction);
 
 Hash arguments (`listRideOffers`, `subscribeRideOffers`) accept the `0x`-prefixed form that `signTransaction` returns; the SDK normalizes them to the form the hub matches on.
 
+## Wallets: MetaMask, Trust Wallet, TronLink
+
+A wallet keeps the key and signs a short text. MetaMask and Trust Wallet sign it with `personal_sign` (EIP-191). TronLink signs it with `signMessageV2` (TIP-191), which is the same with the prefix `\x19TRON Signed Message:\n`. A TronLink account is the same kind of key as a Clutch account, so its `T…` address is the Clutch address `0x…` of the same key. Use a signer where you used a key:
+
+```javascript
+import { ClutchHubSdk, discoverInjectedWallets, connectWallet } from 'clutch-hub-sdk-js';
+
+const [wallet] = await discoverInjectedWallets();   // EIP-6963 and TIP-6963 (TronLink), then window.ethereum / window.tron
+const signer = await connectWallet(wallet);          // the wallet asks the user to share an account
+
+const sdk = new ClutchHubSdk('http://localhost:3000', signer.address, signer, 2077);
+// ... create the unsigned transaction as above ...
+const signed = await sdk.signTransaction(unsigned, signer, { type: 'RideRequest', fare: 5_000_000n });
+```
+
+Each `signTransaction` and each login opens a prompt in the wallet. The text the wallet shows is `clutch-tx:{chainId}:{hash}` for a transaction and `clutch-auth:{chainId}:{address}:{timestamp}` for the login. The node and the Hub API accept this signature next to the signature of a private key. `wallet.kind` is `'evm'` (MetaMask, Trust Wallet) or `'tron'` (TronLink), and `connectWallet`, `createSignerFor(wallet, account)`, `sharedWalletAccount(wallet)` (the account a wallet already shares, with no prompt) and `watchWalletAccounts(wallet, listener)` work for both. `createWalletSigner(provider, address)` and `createTronLinkSigner(provider, address)` build a signer for a provider you already have, and `createLocalSigner(privateKey)` wraps a key. A user who says no in a wallet gives a rejection (MetaMask and Trust Wallet: `code: 4001`; TronLink: an error with the message `user rejected request`).
+
 ## Features
 
-- Client-side signing (private keys never sent to server)
+- Client-side signing (private keys never sent to server), or a wallet that keeps the key (MetaMask, Trust Wallet, TronLink)
 - Full ride lifecycle: request, offer, accept, pay, cancel
 - GraphQL queries and WebSocket subscriptions
 - TypeScript types
@@ -52,7 +69,8 @@ Hash arguments (`listRideOffers`, `subscribeRideOffers`) accept the `0x`-prefixe
 
 | Category | Methods |
 |----------|---------|
-| Auth | Auto `generateToken` via `ensureAuth()` (signed challenge; needs the private key), `setPrivateKey`, `signAuthChallenge` |
+| Auth | Auto `generateToken` via `ensureAuth()` (signed challenge; needs a private key or a signer), `setPrivateKey`, `setSigner`, `signAuthChallenge` |
+| Signers | `createLocalSigner`, `createWalletSigner`, `createTronLinkSigner`, `createSignerFor`, `discoverInjectedWallets`, `connectWallet`, `sharedWalletAccount`, `watchWalletAccounts`, `tronAddressToHex`, `addressFromPrivateKey` |
 | Write | `createUnsignedRide*`, `signTransaction`, `submitTransaction` |
 | Read | `listRideRequests`, `listRideOffers`, `listActiveTrips`, `getAccountBalance`, … |
 | Live | `subscribeRideRequests`, `subscribeRideOffers`, `subscribeActiveTrips`, … |

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './types.js';
 export * from './sdk.js';
+export * from './signers.js';
 export { hubGraphqlWsUrl, RIDE_REQUEST_GQL_FIELDS, RIDE_OFFER_GQL_FIELDS, ACTIVE_TRIP_GQL_FIELDS, RECENT_TRIP_GQL_FIELDS, createHubSubscriptionClient, } from './subscriptions.js';
 export type { SubscriptionHandlers } from './subscriptions.js';

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from './types.js';
 export * from './sdk.js';
+export * from './signers.js';
 export { hubGraphqlWsUrl, RIDE_REQUEST_GQL_FIELDS, RIDE_OFFER_GQL_FIELDS, ACTIVE_TRIP_GQL_FIELDS, RECENT_TRIP_GQL_FIELDS, createHubSubscriptionClient, } from './subscriptions.js';

package/dist/sdk.d.ts

@@ -1,6 +1,7 @@
 import { Buffer } from 'buffer';
 import { type SubscriptionHandlers } from './subscriptions.js';
 import { AvailableRideRequest, AvailableRideOffer, AvailableActiveTrip, AvailableCompletedTrip, AvailableRecentTrip, BurnArgs, MapBounds, RideRequestArgs, RideOfferArgs, RideAcceptanceArgs, RidePayArgs, RideCancelArgs, RideRequestCancelArgs, Signature } from './types.js';
+import type { Signer } from './signers.js';
 /** Strip 0x/0X prefix - hex parsers (e.g. @noble/secp256k1) do not accept it. Exported for consumers. */
 export declare function stripHexPrefix(hex: string): string;
 /**
@@ -46,6 +47,13 @@ export declare function authChallengeHashHex(chainId: number, publicKey: string,
  * @param timestamp Unix seconds; the Hub API rejects timestamps more than ±120s from server time.
  */
 export declare function signAuthChallenge(chainId: number, publicKey: string, timestamp: number, privateKey: string): Promise<Signature>;
+/** The address of a private key: `0x` and 40 lowercase hex characters. */
+export declare function addressFromPrivateKey(privateKey: string): string;
+/**
+ * A signer for a private key held in memory. It signs the hash string, as the SDK always has.
+ * A wallet cannot hand over its key: use `createWalletSigner` for that.
+ */
+export declare function createLocalSigner(privateKey: string): Signer;
 /**
  * Represents an unsigned transaction returned by the GraphQL API.
  */
@@ -120,9 +128,10 @@ export declare class ClutchHubSdk {
     /**
      * @param apiUrl Hub API base URL.
      * @param publicKey Wallet address (0x + 40 hex) or uncompressed public key (130 hex).
-     * @param privateKey Optional wallet private key, required to obtain JWTs: `generateToken`
-     *   demands a signed proof-of-key-ownership challenge. May also be provided later via
-     *   {@link setPrivateKey}. Never sent to the API — only used for local signing.
+     * @param privateKey Optional private key, or a {@link Signer} (for example a wallet's, see
+     *   `createWalletSigner`), required to obtain JWTs: `generateToken` demands a signed
+     *   proof-of-key-ownership challenge. May also be provided later via {@link setPrivateKey}
+     *   or {@link setSigner}. A key is never sent to the API — only used for local signing.
      * @param chainId This chain's id (e.g. 2077 for the app's own config), used for the
      *   chain-bound auth challenge and as the default `expected.chainId` pin in
      *   {@link signTransaction}'s `verifyUnsignedTransaction` check. Get this from app config,
@@ -133,24 +142,33 @@ export declare class ClutchHubSdk {
      * @param options Optional settings — see {@link ClutchHubSdkOptions}. Today that is the HTTP
      *   timeout (`timeoutMs`, default {@link DEFAULT_HTTP_TIMEOUT_MS}).
      */
-    constructor(apiUrl: string, publicKey: string, privateKey?: string, chainId?: number, options?: ClutchHubSdkOptions);
+    constructor(apiUrl: string, publicKey: string, privateKey?: string | Signer, chainId?: number, options?: ClutchHubSdkOptions);
     /**
      * Get the current public key associated with this SDK instance.
      * @returns The public key string
      */
     getPublicKey(): string;
     /**
-     * Provide (or replace) the private key used to sign `generateToken` auth challenges for
-     * this SDK's public key. Stored in a module-global map keyed by publicKey — like the JWT
-     * cache — so every SDK instance and shared WebSocket connection for this wallet can
-     * authenticate. In-memory only; never sent to the API.
+     * Provide (or replace) the private key — or the {@link Signer} — used to sign `generateToken`
+     * auth challenges for this SDK's public key. Stored in a module-global map keyed by
+     * publicKey — like the JWT cache — so every SDK instance and shared WebSocket connection for
+     * this wallet can authenticate. In-memory only; a key is never sent to the API.
      */
-    setPrivateKey(privateKey: string): void;
+    setPrivateKey(privateKey: string | Signer): void;
+    /** Same as {@link setPrivateKey}, for a signer such as a wallet's (`createWalletSigner`). */
+    setSigner(signer: Signer): void;
     /**
      * Check if the SDK is currently authenticated.
      * @returns True if authenticated and token is not expired
      */
     isAuthenticated(): boolean;
+    /**
+     * True when a token for this account is cached and still good, so the next authenticated call
+     * opens no sign-in prompt. `isAuthenticated` looks at this instance only; this looks at the
+     * cache that every instance of the account shares. A poll should check it first: a wallet's
+     * sign-in prompt belongs to something the user did, never to a timer.
+     */
+    hasValidToken(): boolean;
     private get authHeaders();
     /**
      * WebSocket URL for GraphQL subscriptions (same host as REST/GraphQL HTTP).
@@ -161,6 +179,15 @@ export declare class ClutchHubSdk {
      * Call `release` when unsubscribing; last release disposes the socket.
      */
     private acquireGraphqlWsClient;
+    /**
+     * The `connection_init` payload of the shared socket: a token when there is one to send.
+     *
+     * The subscriptions are public, so a token is optional here. This runs at every connect and
+     * every reconnect (the socket retries for ever), with nobody watching, so a signer that opens a
+     * prompt (a wallet) is not asked for a signature: a token from an earlier, explicit action is
+     * still sent. A key signs silently and is asked as before.
+     */
+    private wsConnectionParams;
     /**
      * Shared graphql-ws list subscription: one multiplexed client via {@link acquireGraphqlWsClient}.
      */
@@ -208,8 +235,12 @@ export declare class ClutchHubSdk {
     createUnsignedBurn(args: BurnArgs): Promise<UnsignedTransaction>;
     /**
      * Signs a transaction and returns the signature and raw RLP-encoded payload.
+     *
+     * `privateKey` is a private key, or a {@link Signer}. A key signs the hash string. A wallet's
+     * signer asks the wallet to sign `clutch-tx:{chainId}:{hash}` with `personal_sign`: the user
+     * sees a prompt, so call this only where that is expected.
      */
-    signTransaction(unsignedTx: UnsignedTransaction, privateKey: string, expected?: ExpectedTx): Promise<Signature & {
+    signTransaction(unsignedTx: UnsignedTransaction, privateKey: string | Signer, expected?: ExpectedTx): Promise<Signature & {
         rawTransaction: string;
         txHash: string;
     }>;

package/dist/sdk.js

@@ -54,12 +54,13 @@ const globalTokenCache = new Map();
  */
 const inFlightTokenRequests = new Map();
 /**
- * Module-global private-key store keyed by `publicKey` (parallel to the JWT cache).
+ * Module-global signer store keyed by `publicKey` (parallel to the JWT cache).
  * `generateToken` requires proof of key ownership (a signed challenge), so token issuance
- * needs the wallet's private key. Keys are kept in memory only and are **never** sent to
- * the Hub API — only the challenge signature is.
+ * needs a signer for the account: a private key held in memory (`createLocalSigner`) or a
+ * wallet that signs for it (`createWalletSigner`). A key is kept in memory only and is
+ * **never** sent to the Hub API — only the challenge signature is.
  */
-const globalPrivateKeys = new Map();
+const globalSigners = new Map();
 /** Prefix of the canonical proof-of-key-ownership message signed for `generateToken`. */
 export const AUTH_CHALLENGE_PREFIX = 'clutch-auth';
 /**
@@ -106,6 +107,30 @@ async function signHashHex(hashHex, privateKey) {
 export async function signAuthChallenge(chainId, publicKey, timestamp, privateKey) {
     return signHashHex(authChallengeHashHex(chainId, publicKey, timestamp), privateKey);
 }
+/** The address of a private key: `0x` and 40 lowercase hex characters. */
+export function addressFromPrivateKey(privateKey) {
+    const publicKey = secp.getPublicKey(stripHexPrefix(privateKey), false); // 0x04 || X || Y
+    return '0x' + Buffer.from(keccak_256(publicKey.slice(1)).slice(-20)).toString('hex');
+}
+/**
+ * A signer for a private key held in memory. It signs the hash string, as the SDK always has.
+ * A wallet cannot hand over its key: use `createWalletSigner` for that.
+ */
+export function createLocalSigner(privateKey) {
+    return {
+        // A getter, so that a malformed key still fails when something is signed, as it always did,
+        // and not when the SDK is built.
+        get address() {
+            return addressFromPrivateKey(privateKey);
+        },
+        signTransaction: ({ hashHex }) => signHashHex(hashHex, privateKey),
+        signAuthChallenge: ({ hashHex }) => signHashHex(hashHex, privateKey),
+    };
+}
+/** Everywhere the SDK takes a private key it also takes a signer. */
+function toSigner(keyOrSigner) {
+    return typeof keyOrSigner === 'string' ? createLocalSigner(keyOrSigner) : keyOrSigner;
+}
 /**
  * One graphql-ws connection per hub URL + wallet; multiplex all subscriptions on it.
  * Without this, each subscribe* call opened a new socket (`lazy: false`), which explodes
@@ -120,9 +145,9 @@ function sharedGraphqlWsCacheKey(baseURL, publicKey) {
  * via the `generateToken` mutation when needed. Shared by `ensureAuth` and the WebSocket
  * `connectionParams` so all SDK instances and subscriptions share tokens.
  *
- * Token issuance signs the proof-of-key-ownership challenge, so a private key for
- * `publicKey` must have been provided (constructor or `setPrivateKey`) unless a cached
- * token is still valid.
+ * Token issuance signs the proof-of-key-ownership challenge, so a signer (or a private key)
+ * for `publicKey` must have been provided (constructor, `setPrivateKey` or `setSigner`)
+ * unless a cached token is still valid. With a wallet this is the prompt the user sees.
  */
 async function ensureTokenInCacheForPublicKey(publicKey, apiClient, chainId) {
     const now = Date.now();
@@ -135,9 +160,9 @@ async function ensureTokenInCacheForPublicKey(publicKey, apiClient, chainId) {
     if (existingInFlight) {
         return existingInFlight;
     }
-    const privateKey = globalPrivateKeys.get(publicKey);
-    if (!privateKey) {
-        throw new Error(`ClutchHubSdk: generateToken requires proof of key ownership; provide the private key for ${publicKey} via the ClutchHubSdk constructor or setPrivateKey().`);
+    const signer = globalSigners.get(publicKey);
+    if (!signer) {
+        throw new Error(`ClutchHubSdk: generateToken requires proof of key ownership; provide the private key (or a signer) for ${publicKey} via the ClutchHubSdk constructor, setPrivateKey() or setSigner().`);
     }
     const query = `
     mutation GenerateToken($publicKey: String!, $timestamp: Int!, $signature: AuthSignatureInput!) {
@@ -149,7 +174,10 @@ async function ensureTokenInCacheForPublicKey(publicKey, apiClient, chainId) {
   `;
     const requestPromise = (async () => {
         const timestamp = Math.floor(Date.now() / 1000);
-        const signature = await signAuthChallenge(chainId, publicKey, timestamp, privateKey);
+        const signature = await signer.signAuthChallenge({
+            message: buildAuthChallengeMessage(chainId, publicKey, timestamp),
+            hashHex: authChallengeHashHex(chainId, publicKey, timestamp),
+        });
         const response = await apiClient.post('/graphql', {
             query,
             variables: {
@@ -274,9 +302,10 @@ export class ClutchHubSdk {
     /**
      * @param apiUrl Hub API base URL.
      * @param publicKey Wallet address (0x + 40 hex) or uncompressed public key (130 hex).
-     * @param privateKey Optional wallet private key, required to obtain JWTs: `generateToken`
-     *   demands a signed proof-of-key-ownership challenge. May also be provided later via
-     *   {@link setPrivateKey}. Never sent to the API — only used for local signing.
+     * @param privateKey Optional private key, or a {@link Signer} (for example a wallet's, see
+     *   `createWalletSigner`), required to obtain JWTs: `generateToken` demands a signed
+     *   proof-of-key-ownership challenge. May also be provided later via {@link setPrivateKey}
+     *   or {@link setSigner}. A key is never sent to the API — only used for local signing.
      * @param chainId This chain's id (e.g. 2077 for the app's own config), used for the
      *   chain-bound auth challenge and as the default `expected.chainId` pin in
      *   {@link signTransaction}'s `verifyUnsignedTransaction` check. Get this from app config,
@@ -298,7 +327,7 @@ export class ClutchHubSdk {
         this.chainId = chainId ?? 0;
         this.chainIdConfigured = chainId !== undefined;
         if (privateKey) {
-            globalPrivateKeys.set(publicKey, privateKey);
+            globalSigners.set(publicKey, toSigner(privateKey));
         }
     }
     /**
@@ -309,13 +338,17 @@ export class ClutchHubSdk {
         return this.publicKey;
     }
     /**
-     * Provide (or replace) the private key used to sign `generateToken` auth challenges for
-     * this SDK's public key. Stored in a module-global map keyed by publicKey — like the JWT
-     * cache — so every SDK instance and shared WebSocket connection for this wallet can
-     * authenticate. In-memory only; never sent to the API.
+     * Provide (or replace) the private key — or the {@link Signer} — used to sign `generateToken`
+     * auth challenges for this SDK's public key. Stored in a module-global map keyed by
+     * publicKey — like the JWT cache — so every SDK instance and shared WebSocket connection for
+     * this wallet can authenticate. In-memory only; a key is never sent to the API.
      */
     setPrivateKey(privateKey) {
-        globalPrivateKeys.set(this.publicKey, privateKey);
+        globalSigners.set(this.publicKey, toSigner(privateKey));
+    }
+    /** Same as {@link setPrivateKey}, for a signer such as a wallet's (`createWalletSigner`). */
+    setSigner(signer) {
+        globalSigners.set(this.publicKey, signer);
     }
     /**
      * Check if the SDK is currently authenticated.
@@ -326,6 +359,16 @@ export class ClutchHubSdk {
         const bufferTime = 30000; // 30 seconds
         return !!(this.token && now < (this.tokenExpireTime - bufferTime));
     }
+    /**
+     * True when a token for this account is cached and still good, so the next authenticated call
+     * opens no sign-in prompt. `isAuthenticated` looks at this instance only; this looks at the
+     * cache that every instance of the account shares. A poll should check it first: a wallet's
+     * sign-in prompt belongs to something the user did, never to a timer.
+     */
+    hasValidToken() {
+        const cached = globalTokenCache.get(this.publicKey);
+        return !!cached && Date.now() < cached.expireTimeMs - 30000;
+    }
     get authHeaders() {
         return this.token ? { Authorization: `Bearer ${this.token}` } : {};
     }
@@ -351,21 +394,9 @@ export class ClutchHubSdk {
         const key = sharedGraphqlWsCacheKey(base, this.publicKey);
         let entry = sharedGraphqlWsClients.get(key);
         if (!entry) {
-            const pk = this.publicKey;
-            const apiClient = this.apiClient;
-            const chainId = this.chainId;
             const client = createHubSubscriptionClient({
                 url: hubGraphqlWsUrl(base),
-                connectionParams: async () => {
-                    try {
-                        await ensureTokenInCacheForPublicKey(pk, apiClient, chainId);
-                    }
-                    catch {
-                        /* public list subscriptions work without JWT */
-                    }
-                    const c = globalTokenCache.get(pk);
-                    return c?.token ? { Authorization: `Bearer ${c.token}` } : {};
-                },
+                connectionParams: () => this.wsConnectionParams(),
             });
             entry = { client, refcount: 0 };
             sharedGraphqlWsClients.set(key, entry);
@@ -384,6 +415,29 @@ export class ClutchHubSdk {
         };
         return { client: entry.client, release };
     }
+    /**
+     * The `connection_init` payload of the shared socket: a token when there is one to send.
+     *
+     * The subscriptions are public, so a token is optional here. This runs at every connect and
+     * every reconnect (the socket retries for ever), with nobody watching, so a signer that opens a
+     * prompt (a wallet) is not asked for a signature: a token from an earlier, explicit action is
+     * still sent. A key signs silently and is asked as before.
+     */
+    async wsConnectionParams() {
+        const pk = this.publicKey;
+        if (!globalSigners.get(pk)?.interactive) {
+            try {
+                await ensureTokenInCacheForPublicKey(pk, this.apiClient, this.chainId);
+            }
+            catch {
+                /* public list subscriptions work without JWT */
+            }
+        }
+        const cached = globalTokenCache.get(pk);
+        return cached?.token && Date.now() < cached.expireTimeMs
+            ? { Authorization: `Bearer ${cached.token}` }
+            : {};
+    }
     /**
      * Shared graphql-ws list subscription: one multiplexed client via {@link acquireGraphqlWsClient}.
      */
@@ -579,6 +633,10 @@ export class ClutchHubSdk {
     }
     /**
      * Signs a transaction and returns the signature and raw RLP-encoded payload.
+     *
+     * `privateKey` is a private key, or a {@link Signer}. A key signs the hash string. A wallet's
+     * signer asks the wallet to sign `clutch-tx:{chainId}:{hash}` with `personal_sign`: the user
+     * sees a prompt, so call this only where that is expected.
      */
     async signTransaction(unsignedTx, privateKey, expected) {
         if (expected) {
@@ -619,7 +677,10 @@ export class ClutchHubSdk {
         const hashBytes = keccak_256(unsignedPayload);
         const rawHashHex = Buffer.from(hashBytes).toString('hex');
         // Sign the transaction hash
-        const signature = await signHashHex(rawHashHex, privateKey);
+        const signature = await toSigner(privateKey).signTransaction({
+            hashHex: rawHashHex,
+            chainId: unsignedTx.chain_id,
+        });
         const rNo0x = stripHexPrefix(signature.r);
         const sNo0x = stripHexPrefix(signature.s);
         // RLP-encode full signed transaction to match Rust: [from, nonce, chain_id, r, s, v, hash, data]

package/dist/signers.d.ts

@@ -0,0 +1,151 @@
+import type { Signature } from './types.js';
+/** What a signer is asked to sign to send a transaction. */
+export interface TransactionSigningRequest {
+    /** Keccak-256 of the unsigned transaction: 64 lowercase hex characters, no `0x`. */
+    hashHex: string;
+    /** The chain the transaction is for. A wallet's prompt names it. */
+    chainId: number;
+}
+/** What a signer is asked to sign to prove it owns a key to the Hub API. */
+export interface AuthChallengeSigningRequest {
+    /** The readable challenge, `clutch-auth:{chainId}:{publicKey}:{timestamp}`. */
+    message: string;
+    /** Keccak-256 of `message`: 64 lowercase hex characters, no `0x`. */
+    hashHex: string;
+}
+/** Something that can sign for one account. */
+export interface Signer {
+    /** The account this signer signs for: `0x` and 40 lowercase hex characters. */
+    readonly address: string;
+    /**
+     * True when signing opens a prompt for a person (a wallet). The SDK never asks such a signer for
+     * a signature in the background, for example when a subscription reconnects; only a call the
+     * app makes (create or sign a transaction) can open a prompt.
+     */
+    readonly interactive?: boolean;
+    /** Sign a transaction. A key signs the hash string; a wallet signs `walletTransactionText`. */
+    signTransaction(request: TransactionSigningRequest): Promise<Signature>;
+    /** Sign the Hub API's proof-of-key-ownership challenge. A key signs its hash; a wallet signs the message. */
+    signAuthChallenge(request: AuthChallengeSigningRequest): Promise<Signature>;
+}
+/**
+ * The part of an EIP-1193 provider (`window.ethereum`, an EIP-6963 provider) that the SDK uses.
+ * `on` and `removeListener` are there for apps that watch `accountsChanged`.
+ */
+export interface Eip1193Provider {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on?(event: string, listener: (...args: any[]) => void): void;
+    removeListener?(event: string, listener: (...args: any[]) => void): void;
+}
+/** The text a wallet signs for a transaction. The hash is written without `0x`, in lower case. */
+export declare function walletTransactionText(chainId: number, hashHex: string): string;
+/** What `personal_sign` hashes and signs: `Keccak256("\x19Ethereum Signed Message:\n" + length + text)`. */
+export declare function personalSignDigest(text: string): Uint8Array;
+/** What TronLink's `signMessageV2` (TIP-191) hashes and signs: `Keccak256("\x19TRON Signed Message:\n" + length + text)`. */
+export declare function tronSignDigest(text: string): Uint8Array;
+/**
+ * A signer that asks a wallet to sign with `personal_sign`. The wallet shows the user the text,
+ * and keeps the key. `address` is the account to sign for; it is lowercased, because the hash of a
+ * transaction commits to `from` and the node reads `from` in lower case.
+ *
+ * The signature is checked here before it is returned: a wallet that signs with another account
+ * (the user switched accounts) would otherwise be found out later, as a refusal from the node
+ * that does not say why.
+ */
+export declare function createWalletSigner(provider: Eip1193Provider, address: string): Signer;
+/**
+ * A TRON address as the Clutch address of the same key: `0x` and 40 lowercase hex characters.
+ *
+ * A TRON account is an Ethereum-type key (the same curve, the same Keccak-256, the same 20 address
+ * bytes). TRON writes those bytes in base58 (`T…`): `0x41`, the 20 bytes, and 4 bytes of checksum,
+ * and the checksum is checked here. A `0x` address and the `41…` hex form are accepted as they are.
+ */
+export declare function tronAddressToHex(address: string): string;
+/** The part of the `tronWeb` that TronLink puts on its provider that the SDK uses. */
+export interface TronWebLike {
+    ready?: boolean;
+    defaultAddress?: {
+        base58?: string | false;
+    };
+    trx?: {
+        signMessageV2?(message: string): Promise<unknown>;
+    };
+}
+/**
+ * TronLink's provider (`window.tron`, or the one it announces with TIP-6963): EIP-1193 plus a
+ * `tronWeb`, which is `false` until the person lets this site use TronLink.
+ */
+export interface TronLinkProvider extends Eip1193Provider {
+    tronWeb?: TronWebLike | false;
+}
+/**
+ * A signer that asks TronLink to sign with `signMessageV2` (TIP-191). TronLink shows the person the
+ * text and keeps the key. `address` is the account to sign for (a `0x` address, or the base58 one
+ * TronLink shows). It is checked the same way `createWalletSigner` checks: the signature is
+ * recovered here, and one from another account is refused before it leaves the SDK.
+ *
+ * TronLink's documentation is not clear on what `signMessageV2` takes: one page says a hex string
+ * and another says plain text or hex. So the text goes in plain first. A TronLink that takes only
+ * hex answers "Invalid transaction provided" before it opens a prompt, and then the text goes in
+ * again as `0x` hex of its UTF-8 bytes. Any other answer ends the call, because a second try would
+ * open a second prompt.
+ */
+export declare function createTronLinkSigner(provider: TronLinkProvider, address: string): Signer;
+/** A wallet found in the page. */
+export interface InjectedWallet {
+    /** The EIP-6963 or TIP-6963 `rdns` (for example `io.metamask`), or `injected-0` for a bare `window.ethereum`. */
+    id: string;
+    name: string;
+    /** A `data:` image address from the wallet, when it announced one. */
+    icon?: string;
+    /**
+     * `evm` (MetaMask, Trust Wallet: signs with `personal_sign`) or `tron` (TronLink: signs with
+     * `signMessageV2`). Default `evm`.
+     */
+    kind?: 'evm' | 'tron';
+    /** For a `tron` wallet this is a {@link TronLinkProvider}. */
+    provider: Eip1193Provider;
+}
+export interface WalletDiscoveryOptions {
+    /** Where to look. Default: `window`. */
+    host?: EventTarget & {
+        ethereum?: unknown;
+        tron?: unknown;
+        tronLink?: unknown;
+    };
+    /** How long to listen for EIP-6963 and TIP-6963 announcements, in milliseconds. Default: 300. */
+    timeoutMs?: number;
+}
+/**
+ * The wallets in this page. A wallet that follows EIP-6963 (MetaMask, Trust Wallet) or TIP-6963
+ * (TronLink, the same idea for TRON) announces itself, so several can be listed side by side. One
+ * that only sets a global is added when no announced wallet is that same provider: `window.ethereum`
+ * (older wallets, some in-app browsers), or `window.tron` / `window.tronLink` for TronLink. Returns
+ * an empty list when there is no wallet, or when there is no page (Node).
+ */
+export declare function discoverInjectedWallets(options?: WalletDiscoveryOptions): Promise<InjectedWallet[]>;
+/**
+ * Ask a wallet to share its account (the wallet shows its own prompt) and return a signer for it.
+ * Rejects when the user says no (the provider's error, code 4001) or when no account is shared.
+ */
+export declare function connectWallet(wallet: InjectedWallet): Promise<Signer>;
+/** A signer for `account` on `wallet`: `personal_sign` for MetaMask and Trust Wallet, `signMessageV2` for TronLink. */
+export declare function createSignerFor(wallet: InjectedWallet, account: string): Signer;
+/** The first account in an answer of this wallet (`accountsChanged`), as a Clutch address; `null` when there is none. */
+export declare function walletAccountFrom(wallet: InjectedWallet, accounts: unknown): string | null;
+/**
+ * The account a wallet already shares with this page, as a Clutch address. It never opens a
+ * prompt, so an app can use it to connect again by itself on the next visit. `null` when the wallet
+ * shares none (locked, or the site was never allowed). A TronLink that allowed the site earlier has
+ * its `tronWeb` ready; one that did not has `tronWeb` `false`.
+ */
+export declare function sharedWalletAccount(wallet: InjectedWallet): Promise<string | null>;
+/**
+ * Call `listener` with the new account (a Clutch address) when the person switches account in the
+ * wallet, and with `null` when the wallet stops sharing this site (locked, or disconnected).
+ * Returns a function that stops listening.
+ */
+export declare function watchWalletAccounts(wallet: InjectedWallet, listener: (account: string | null) => void): () => void;