@buildersgarden/siwa 0.0.13 → 0.0.15

package/dist/signer/circle.d.ts

@@ -0,0 +1,79 @@
+/**
+ * circle.ts
+ *
+ * Circle developer-controlled wallet signer implementation.
+ */
+import type { CircleDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";
+import type { Address } from "viem";
+import type { Signer } from "./types.js";
+/**
+ * Configuration for the Circle SIWA signer.
+ */
+export interface CircleSiwaSignerConfig {
+    /** Circle API key */
+    apiKey: string;
+    /** Circle entity secret */
+    entitySecret: string;
+    /** Circle wallet ID */
+    walletId: string;
+    /** Wallet address (optional - will be fetched from Circle if not provided) */
+    walletAddress?: Address;
+}
+/**
+ * Configuration using an existing Circle client.
+ */
+export interface CircleSiwaSignerClientConfig {
+    /** Existing Circle client instance */
+    client: CircleDeveloperControlledWalletsClient;
+    /** Circle wallet ID */
+    walletId: string;
+    /** Wallet address (optional - will be fetched from Circle if not provided) */
+    walletAddress?: Address;
+}
+/**
+ * Creates a SIWA Signer that wraps Circle's developer-controlled wallet SDK.
+ *
+ * This signer implements the core Signer interface for SIWA message signing.
+ * It supports both standard message signing (EIP-191) and raw hex signing
+ * for ERC-8128 HTTP message signatures.
+ *
+ * The wallet address can be provided explicitly or fetched automatically
+ * from Circle using the wallet ID.
+ *
+ * @param config - Circle wallet configuration
+ * @returns A Promise that resolves to a Signer compatible with SIWA's signSIWAMessage function
+ *
+ * @example
+ * ```typescript
+ * import { signSIWAMessage, generateNonce } from '@buildersgarden/siwa/siwa';
+ * import { createCircleSiwaSigner } from '@buildersgarden/siwa/signer';
+ *
+ * // Address is fetched automatically from Circle
+ * const signer = await createCircleSiwaSigner({
+ *   apiKey: process.env.CIRCLE_API_KEY!,
+ *   entitySecret: process.env.CIRCLE_ENTITY_SECRET!,
+ *   walletId: 'your-wallet-id',
+ * });
+ *
+ * const { message, signature, address } = await signSIWAMessage({
+ *   domain: 'example.com',
+ *   uri: 'https://example.com/login',
+ *   agentId: 123,
+ *   agentRegistry: 'eip155:84532:0x...',
+ *   chainId: 84532,
+ *   nonce: generateNonce(),
+ *   issuedAt: new Date().toISOString(),
+ * }, signer);
+ * ```
+ */
+export declare function createCircleSiwaSigner(config: CircleSiwaSignerConfig): Promise<Signer>;
+/**
+ * Creates a SIWA Signer from an existing Circle client instance.
+ *
+ * Use this when you already have a Circle client initialized and want
+ * to reuse it for SIWA signing.
+ *
+ * @param config - Configuration with existing Circle client
+ * @returns A Promise that resolves to a Signer compatible with SIWA's signSIWAMessage function
+ */
+export declare function createCircleSiwaSignerFromClient(config: CircleSiwaSignerClientConfig): Promise<Signer>;

package/dist/signer/circle.js

@@ -0,0 +1,120 @@
+/**
+ * circle.ts
+ *
+ * Circle developer-controlled wallet signer implementation.
+ */
+import { initiateDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";
+/**
+ * Fetches wallet address from Circle API using the wallet ID.
+ */
+async function fetchWalletAddress(client, walletId) {
+    const response = await client.getWallet({ id: walletId });
+    const address = response.data?.wallet?.address;
+    if (!address) {
+        throw new Error(`Failed to fetch wallet address for wallet ID: ${walletId}`);
+    }
+    return address;
+}
+/**
+ * Creates a SIWA Signer that wraps Circle's developer-controlled wallet SDK.
+ *
+ * This signer implements the core Signer interface for SIWA message signing.
+ * It supports both standard message signing (EIP-191) and raw hex signing
+ * for ERC-8128 HTTP message signatures.
+ *
+ * The wallet address can be provided explicitly or fetched automatically
+ * from Circle using the wallet ID.
+ *
+ * @param config - Circle wallet configuration
+ * @returns A Promise that resolves to a Signer compatible with SIWA's signSIWAMessage function
+ *
+ * @example
+ * ```typescript
+ * import { signSIWAMessage, generateNonce } from '@buildersgarden/siwa/siwa';
+ * import { createCircleSiwaSigner } from '@buildersgarden/siwa/signer';
+ *
+ * // Address is fetched automatically from Circle
+ * const signer = await createCircleSiwaSigner({
+ *   apiKey: process.env.CIRCLE_API_KEY!,
+ *   entitySecret: process.env.CIRCLE_ENTITY_SECRET!,
+ *   walletId: 'your-wallet-id',
+ * });
+ *
+ * const { message, signature, address } = await signSIWAMessage({
+ *   domain: 'example.com',
+ *   uri: 'https://example.com/login',
+ *   agentId: 123,
+ *   agentRegistry: 'eip155:84532:0x...',
+ *   chainId: 84532,
+ *   nonce: generateNonce(),
+ *   issuedAt: new Date().toISOString(),
+ * }, signer);
+ * ```
+ */
+export async function createCircleSiwaSigner(config) {
+    const client = initiateDeveloperControlledWalletsClient({
+        apiKey: config.apiKey,
+        entitySecret: config.entitySecret,
+    });
+    return createCircleSiwaSignerFromClient({
+        client,
+        walletId: config.walletId,
+        ...(config.walletAddress && { walletAddress: config.walletAddress }),
+    });
+}
+/**
+ * Creates a SIWA Signer from an existing Circle client instance.
+ *
+ * Use this when you already have a Circle client initialized and want
+ * to reuse it for SIWA signing.
+ *
+ * @param config - Configuration with existing Circle client
+ * @returns A Promise that resolves to a Signer compatible with SIWA's signSIWAMessage function
+ */
+export async function createCircleSiwaSignerFromClient(config) {
+    const { client, walletId } = config;
+    // Fetch wallet address from Circle if not provided
+    const walletAddress = config.walletAddress ?? (await fetchWalletAddress(client, walletId));
+    return {
+        /**
+         * Returns the wallet address.
+         */
+        async getAddress() {
+            return walletAddress;
+        },
+        /**
+         * Signs a message using EIP-191 personal_sign.
+         * Used for standard SIWA message signing.
+         */
+        async signMessage(message) {
+            const response = await client.signMessage({
+                walletId,
+                message,
+                encodedByHex: false,
+            });
+            const signature = response.data?.signature;
+            if (!signature) {
+                throw new Error("Circle signMessage failed: no signature returned");
+            }
+            return signature;
+        },
+        /**
+         * Signs raw hex bytes.
+         * Used by ERC-8128 for HTTP message signatures.
+         */
+        async signRawMessage(rawHex) {
+            // Strip 0x prefix if present for Circle API
+            const hexMessage = rawHex.startsWith("0x") ? rawHex.slice(2) : rawHex;
+            const response = await client.signMessage({
+                walletId,
+                message: hexMessage,
+                encodedByHex: true,
+            });
+            const signature = response.data?.signature;
+            if (!signature) {
+                throw new Error("Circle signRawMessage failed: no signature returned");
+            }
+            return signature;
+        },
+    };
+}

package/dist/signer/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * signer/index.ts
+ *
+ * Wallet-agnostic signing abstraction for SIWA.
+ *
+ * This module provides a `Signer` interface that abstracts signing operations,
+ * allowing developers to use any wallet provider without changing the SDK.
+ *
+ * Available signer implementations:
+ *   - createKeyringProxySigner(config)         — Keyring proxy server (HMAC-authenticated)
+ *   - createLocalAccountSigner(account)        — viem LocalAccount (privateKeyToAccount)
+ *   - createWalletClientSigner(client)         — viem WalletClient (Privy, MetaMask, etc.)
+ *   - createCircleSiwaSigner(config)           — Circle developer-controlled wallet
+ *   - createCircleSiwaSignerFromClient(config) — Circle with existing client
+ *   - createPrivySiwaSigner(config)            — Privy server wallet
+ *
+ * Usage:
+ *   import { signSIWAMessage, createLocalAccountSigner } from '@buildersgarden/siwa';
+ *   import { privateKeyToAccount } from 'viem/accounts';
+ *
+ *   const account = privateKeyToAccount('0x...');
+ *   const signer = createLocalAccountSigner(account);
+ *   const { message, signature } = await signSIWAMessage(fields, signer);
+ */
+export type { Signer, SignerType, TransactionSigner, TransactionRequest, KeyringProxyConfig, } from './types.js';
+export { createKeyringProxySigner } from './keyring-proxy.js';
+export { createLocalAccountSigner } from './local-account.js';
+export { createWalletClientSigner } from './wallet-client.js';
+export { createCircleSiwaSigner, createCircleSiwaSignerFromClient, type CircleSiwaSignerConfig, type CircleSiwaSignerClientConfig, } from './circle.js';
+export { createPrivySiwaSigner, type PrivySiwaSignerConfig, } from './privy.js';

package/dist/signer/index.js

@@ -0,0 +1,30 @@
+/**
+ * signer/index.ts
+ *
+ * Wallet-agnostic signing abstraction for SIWA.
+ *
+ * This module provides a `Signer` interface that abstracts signing operations,
+ * allowing developers to use any wallet provider without changing the SDK.
+ *
+ * Available signer implementations:
+ *   - createKeyringProxySigner(config)         — Keyring proxy server (HMAC-authenticated)
+ *   - createLocalAccountSigner(account)        — viem LocalAccount (privateKeyToAccount)
+ *   - createWalletClientSigner(client)         — viem WalletClient (Privy, MetaMask, etc.)
+ *   - createCircleSiwaSigner(config)           — Circle developer-controlled wallet
+ *   - createCircleSiwaSignerFromClient(config) — Circle with existing client
+ *   - createPrivySiwaSigner(config)            — Privy server wallet
+ *
+ * Usage:
+ *   import { signSIWAMessage, createLocalAccountSigner } from '@buildersgarden/siwa';
+ *   import { privateKeyToAccount } from 'viem/accounts';
+ *
+ *   const account = privateKeyToAccount('0x...');
+ *   const signer = createLocalAccountSigner(account);
+ *   const { message, signature } = await signSIWAMessage(fields, signer);
+ */
+// Signer implementations
+export { createKeyringProxySigner } from './keyring-proxy.js';
+export { createLocalAccountSigner } from './local-account.js';
+export { createWalletClientSigner } from './wallet-client.js';
+export { createCircleSiwaSigner, createCircleSiwaSignerFromClient, } from './circle.js';
+export { createPrivySiwaSigner, } from './privy.js';

package/dist/signer/keyring-proxy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * keyring-proxy.ts
+ *
+ * Keyring proxy signer implementation.
+ * Delegates signing to a secure keyring proxy server via HMAC-authenticated HTTP requests.
+ */
+import type { KeyringProxyConfig, TransactionSigner } from './types.js';
+/**
+ * Create a signer backed by the keyring proxy server.
+ *
+ * The private key is stored securely in the proxy server and never
+ * enters the calling process. All signing operations are performed
+ * via HMAC-authenticated HTTP requests.
+ *
+ * @param config - Proxy URL and secret (or use env vars)
+ * @returns A TransactionSigner that delegates to the keyring proxy
+ *
+ * @example
+ * ```typescript
+ * const signer = createKeyringProxySigner({
+ *   proxyUrl: 'http://localhost:3100',
+ *   proxySecret: 'my-secret',
+ * });
+ * const { message, signature } = await signSIWAMessage(fields, signer);
+ * ```
+ */
+export declare function createKeyringProxySigner(config?: KeyringProxyConfig): TransactionSigner;

package/dist/signer/keyring-proxy.js

@@ -0,0 +1,77 @@
+/**
+ * keyring-proxy.ts
+ *
+ * Keyring proxy signer implementation.
+ * Delegates signing to a secure keyring proxy server via HMAC-authenticated HTTP requests.
+ */
+import { computeHmac } from '../proxy-auth.js';
+/**
+ * Internal helper for HMAC-authenticated proxy requests.
+ */
+async function proxyRequest(config, endpoint, body = {}) {
+    const url = config.proxyUrl || process.env.KEYRING_PROXY_URL;
+    const secret = config.proxySecret || process.env.KEYRING_PROXY_SECRET;
+    if (!url) {
+        throw new Error('Keyring proxy requires KEYRING_PROXY_URL or config.proxyUrl');
+    }
+    if (!secret) {
+        throw new Error('Keyring proxy requires KEYRING_PROXY_SECRET or config.proxySecret');
+    }
+    const bodyStr = JSON.stringify(body, (_key, value) => typeof value === 'bigint' ? '0x' + value.toString(16) : value);
+    const hmacHeaders = computeHmac(secret, 'POST', endpoint, bodyStr);
+    const res = await fetch(`${url}${endpoint}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...hmacHeaders,
+        },
+        body: bodyStr,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Proxy ${endpoint} failed (${res.status}): ${text}`);
+    }
+    return res.json();
+}
+/**
+ * Create a signer backed by the keyring proxy server.
+ *
+ * The private key is stored securely in the proxy server and never
+ * enters the calling process. All signing operations are performed
+ * via HMAC-authenticated HTTP requests.
+ *
+ * @param config - Proxy URL and secret (or use env vars)
+ * @returns A TransactionSigner that delegates to the keyring proxy
+ *
+ * @example
+ * ```typescript
+ * const signer = createKeyringProxySigner({
+ *   proxyUrl: 'http://localhost:3100',
+ *   proxySecret: 'my-secret',
+ * });
+ * const { message, signature } = await signSIWAMessage(fields, signer);
+ * ```
+ */
+export function createKeyringProxySigner(config = {}) {
+    return {
+        async getAddress() {
+            const data = await proxyRequest(config, '/get-address');
+            return data.address;
+        },
+        async signMessage(message) {
+            const data = await proxyRequest(config, '/sign-message', { message });
+            return data.signature;
+        },
+        async signRawMessage(rawHex) {
+            const data = await proxyRequest(config, '/sign-message', {
+                message: rawHex,
+                raw: true,
+            });
+            return data.signature;
+        },
+        async signTransaction(tx) {
+            const data = await proxyRequest(config, '/sign-transaction', { tx });
+            return data.signedTx;
+        },
+    };
+}

package/dist/signer/local-account.d.ts

@@ -0,0 +1,26 @@
+/**
+ * local-account.ts
+ *
+ * Local account signer implementation using viem LocalAccount.
+ */
+import type { LocalAccount } from 'viem/accounts';
+import type { TransactionSigner } from './types.js';
+/**
+ * Create a signer from a viem LocalAccount.
+ *
+ * Use this when you have direct access to a private key via
+ * viem's `privateKeyToAccount()` or similar.
+ *
+ * @param account - A viem LocalAccount (from privateKeyToAccount, mnemonicToAccount, etc.)
+ * @returns A TransactionSigner that signs using the local account
+ *
+ * @example
+ * ```typescript
+ * import { privateKeyToAccount } from 'viem/accounts';
+ *
+ * const account = privateKeyToAccount('0x...');
+ * const signer = createLocalAccountSigner(account);
+ * const { message, signature } = await signSIWAMessage(fields, signer);
+ * ```
+ */
+export declare function createLocalAccountSigner(account: LocalAccount): TransactionSigner;

package/dist/signer/local-account.js

@@ -0,0 +1,39 @@
+/**
+ * local-account.ts
+ *
+ * Local account signer implementation using viem LocalAccount.
+ */
+/**
+ * Create a signer from a viem LocalAccount.
+ *
+ * Use this when you have direct access to a private key via
+ * viem's `privateKeyToAccount()` or similar.
+ *
+ * @param account - A viem LocalAccount (from privateKeyToAccount, mnemonicToAccount, etc.)
+ * @returns A TransactionSigner that signs using the local account
+ *
+ * @example
+ * ```typescript
+ * import { privateKeyToAccount } from 'viem/accounts';
+ *
+ * const account = privateKeyToAccount('0x...');
+ * const signer = createLocalAccountSigner(account);
+ * const { message, signature } = await signSIWAMessage(fields, signer);
+ * ```
+ */
+export function createLocalAccountSigner(account) {
+    return {
+        async getAddress() {
+            return account.address;
+        },
+        async signMessage(message) {
+            return account.signMessage({ message });
+        },
+        async signRawMessage(rawHex) {
+            return account.signMessage({ message: { raw: rawHex } });
+        },
+        async signTransaction(tx) {
+            return account.signTransaction(tx);
+        },
+    };
+}

package/dist/signer/privy.d.ts

@@ -0,0 +1,58 @@
+/**
+ * privy.ts
+ *
+ * Privy server wallet signer implementation.
+ */
+import type { PrivyClient } from "@privy-io/node";
+import type { Address } from "viem";
+import type { Signer } from "./types.js";
+/**
+ * Configuration for the Privy SIWA signer.
+ */
+export interface PrivySiwaSignerConfig {
+    /** Privy client instance */
+    client: PrivyClient;
+    /** Privy wallet ID */
+    walletId: string;
+    /** Wallet address */
+    walletAddress: Address;
+}
+/**
+ * Creates a SIWA Signer that wraps Privy's server wallet SDK.
+ *
+ * This signer implements the core Signer interface for SIWA message signing.
+ * It supports both standard message signing (EIP-191) and raw hex signing
+ * for ERC-8128 HTTP message signatures.
+ *
+ * @param config - Privy wallet configuration
+ * @returns A Signer compatible with SIWA's signSIWAMessage function
+ *
+ * @example
+ * ```typescript
+ * import { PrivyClient } from '@privy-io/node';
+ * import { signSIWAMessage, generateNonce } from '@buildersgarden/siwa/siwa';
+ * import { createPrivySiwaSigner } from '@buildersgarden/siwa/signer';
+ *
+ * const privy = new PrivyClient({
+ *   appId: process.env.PRIVY_APP_ID!,
+ *   appSecret: process.env.PRIVY_APP_SECRET!,
+ * });
+ *
+ * const signer = createPrivySiwaSigner({
+ *   client: privy,
+ *   walletId: 'your-wallet-id',
+ *   walletAddress: '0x...',
+ * });
+ *
+ * const { message, signature, address } = await signSIWAMessage({
+ *   domain: 'example.com',
+ *   uri: 'https://example.com/login',
+ *   agentId: 123,
+ *   agentRegistry: 'eip155:84532:0x...',
+ *   chainId: 84532,
+ *   nonce: generateNonce(),
+ *   issuedAt: new Date().toISOString(),
+ * }, signer);
+ * ```
+ */
+export declare function createPrivySiwaSigner(config: PrivySiwaSignerConfig): Signer;

package/dist/signer/privy.js

@@ -0,0 +1,74 @@
+/**
+ * privy.ts
+ *
+ * Privy server wallet signer implementation.
+ */
+/**
+ * Creates a SIWA Signer that wraps Privy's server wallet SDK.
+ *
+ * This signer implements the core Signer interface for SIWA message signing.
+ * It supports both standard message signing (EIP-191) and raw hex signing
+ * for ERC-8128 HTTP message signatures.
+ *
+ * @param config - Privy wallet configuration
+ * @returns A Signer compatible with SIWA's signSIWAMessage function
+ *
+ * @example
+ * ```typescript
+ * import { PrivyClient } from '@privy-io/node';
+ * import { signSIWAMessage, generateNonce } from '@buildersgarden/siwa/siwa';
+ * import { createPrivySiwaSigner } from '@buildersgarden/siwa/signer';
+ *
+ * const privy = new PrivyClient({
+ *   appId: process.env.PRIVY_APP_ID!,
+ *   appSecret: process.env.PRIVY_APP_SECRET!,
+ * });
+ *
+ * const signer = createPrivySiwaSigner({
+ *   client: privy,
+ *   walletId: 'your-wallet-id',
+ *   walletAddress: '0x...',
+ * });
+ *
+ * const { message, signature, address } = await signSIWAMessage({
+ *   domain: 'example.com',
+ *   uri: 'https://example.com/login',
+ *   agentId: 123,
+ *   agentRegistry: 'eip155:84532:0x...',
+ *   chainId: 84532,
+ *   nonce: generateNonce(),
+ *   issuedAt: new Date().toISOString(),
+ * }, signer);
+ * ```
+ */
+export function createPrivySiwaSigner(config) {
+    const { client, walletId, walletAddress } = config;
+    return {
+        /**
+         * Returns the wallet address.
+         */
+        async getAddress() {
+            return walletAddress;
+        },
+        /**
+         * Signs a message using EIP-191 personal_sign.
+         * Used for standard SIWA message signing.
+         */
+        async signMessage(message) {
+            const result = await client.wallets().ethereum().signMessage(walletId, {
+                message,
+            });
+            return result.signature;
+        },
+        /**
+         * Signs raw hex bytes.
+         * Used by ERC-8128 for HTTP message signatures.
+         */
+        async signRawMessage(rawHex) {
+            const result = await client.wallets().ethereum().signMessage(walletId, {
+                message: rawHex,
+            });
+            return result.signature;
+        },
+    };
+}

package/dist/signer/types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * types.ts
+ *
+ * Core signer types and interfaces for SIWA.
+ */
+import type { Address, Hex } from 'viem';
+/**
+ * Signer type detected during SIWA sign-in.
+ *
+ * - `'eoa'` — Externally Owned Account (ECDSA key pair)
+ * - `'sca'` — Smart Contract Account (ERC-1271, e.g. Safe, TBA, Kernel)
+ */
+export type SignerType = 'eoa' | 'sca';
+/**
+ * Core signer interface for message signing.
+ *
+ * Implement this interface to add support for new wallet providers.
+ */
+export interface Signer {
+    /** Get the signer's address */
+    getAddress(): Promise<Address>;
+    /** Sign a message (EIP-191 personal_sign) */
+    signMessage(message: string): Promise<Hex>;
+    /**
+     * Sign raw bytes (optional).
+     * Used by ERC-8128 for HTTP message signatures.
+     * If not implemented, signMessage will be used as fallback.
+     */
+    signRawMessage?(rawHex: Hex): Promise<Hex>;
+}
+/**
+ * Extended signer with transaction signing capabilities.
+ *
+ * Required for onchain operations like agent registration.
+ */
+export interface TransactionSigner extends Signer {
+    /** Sign a transaction and return the serialized signed transaction */
+    signTransaction(tx: TransactionRequest): Promise<Hex>;
+}
+/** Transaction request compatible with viem */
+export interface TransactionRequest {
+    to?: Address;
+    data?: Hex;
+    value?: bigint;
+    nonce?: number;
+    chainId?: number;
+    gas?: bigint;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    gasPrice?: bigint;
+    type?: number | string;
+    accessList?: any[];
+}
+/** Configuration for the keyring proxy signer */
+export interface KeyringProxyConfig {
+    /** URL of the keyring proxy server (or KEYRING_PROXY_URL env var) */
+    proxyUrl?: string;
+    /** HMAC shared secret (or KEYRING_PROXY_SECRET env var) */
+    proxySecret?: string;
+}

package/dist/signer/types.js

@@ -0,0 +1,6 @@
+/**
+ * types.ts
+ *
+ * Core signer types and interfaces for SIWA.
+ */
+export {};

package/dist/signer/wallet-client.d.ts

@@ -0,0 +1,36 @@
+/**
+ * wallet-client.ts
+ *
+ * WalletClient signer implementation for browser wallets and embedded wallets.
+ */
+import type { Address, WalletClient } from 'viem';
+import type { Signer } from './types.js';
+/**
+ * Create a signer from a viem WalletClient.
+ *
+ * Use this for browser wallets (MetaMask, etc.), embedded wallets (Privy),
+ * WalletConnect, or any wallet that provides an EIP-1193 provider.
+ *
+ * @param client - A viem WalletClient
+ * @param account - Optional specific account address to use
+ * @returns A Signer that delegates to the WalletClient
+ *
+ * @example
+ * ```typescript
+ * // With Privy embedded wallet
+ * const provider = await privyWallet.getEthereumProvider();
+ * const walletClient = createWalletClient({
+ *   chain: baseSepolia,
+ *   transport: custom(provider),
+ * });
+ * const signer = createWalletClientSigner(walletClient);
+ *
+ * // With browser wallet (MetaMask)
+ * const walletClient = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * });
+ * const signer = createWalletClientSigner(walletClient);
+ * ```
+ */
+export declare function createWalletClientSigner(client: WalletClient, account?: Address): Signer;