@opensea/wallet-adapters 0.1.0

package/README.md

@@ -0,0 +1,145 @@
+# @opensea/wallet-adapters
+
+Provider-agnostic wallet adapters for signing and sending transactions across managed and local backends.
+
+## Features
+
+- **Provider-agnostic interface** — unified `WalletAdapter` abstraction with capabilities declaration
+- **Managed providers** — Privy, Turnkey, Fireblocks (handle gas/nonce server-side)
+- **Local providers** — PrivateKey (handle gas/nonce client-side via RPC)
+- **Framework bridges** — optional adapters for viem and ethers.js
+- **Zero heavy dependencies** — core uses Web Crypto + `@noble/hashes` / `@noble/curves`
+- **Auto-detection** — `createWalletFromEnv()` picks the right provider from environment variables
+
+## Installation
+
+```bash
+npm install @opensea/wallet-adapters
+# or
+pnpm add @opensea/wallet-adapters
+```
+
+## Quick Start
+
+```ts
+import { createWalletFromEnv } from "@opensea/wallet-adapters"
+
+// Auto-detects provider from environment variables
+// Priority: Privy > Fireblocks > Turnkey > PrivateKey
+const wallet = createWalletFromEnv()
+
+const address = await wallet.getAddress()
+const result = await wallet.sendTransaction({
+  to: "0x...",
+  data: "0x...",
+  value: "0",
+  chainId: 8453,
+})
+console.log(`TX hash: ${result.hash}`)
+```
+
+## Adapters
+
+### Privy
+
+Server-side wallet via Privy's API. Handles gas estimation and nonce management.
+
+```ts
+import { PrivyAdapter } from "@opensea/wallet-adapters"
+
+const wallet = PrivyAdapter.fromEnv()
+// Requires: PRIVY_APP_ID, PRIVY_APP_SECRET, PRIVY_WALLET_ID
+```
+
+### Fireblocks
+
+Enterprise MPC custody via Fireblocks API.
+
+```ts
+import { FireblocksAdapter } from "@opensea/wallet-adapters"
+
+const wallet = FireblocksAdapter.fromEnv()
+// Requires: FIREBLOCKS_API_KEY, FIREBLOCKS_API_SECRET, FIREBLOCKS_VAULT_ID
+```
+
+### Turnkey
+
+HSM-backed signing with P-256 stamp authentication.
+
+```ts
+import { TurnkeyAdapter } from "@opensea/wallet-adapters"
+
+const wallet = TurnkeyAdapter.fromEnv()
+// Requires: TURNKEY_API_PUBLIC_KEY, TURNKEY_API_PRIVATE_KEY,
+//           TURNKEY_ORGANIZATION_ID, TURNKEY_WALLET_ADDRESS, TURNKEY_RPC_URL
+```
+
+### PrivateKey
+
+Local signing for development and testing.
+
+```ts
+import { PrivateKeyAdapter } from "@opensea/wallet-adapters"
+
+const wallet = PrivateKeyAdapter.fromEnv()
+// Requires: PRIVATE_KEY, RPC_URL
+```
+
+## Framework Bridges
+
+### viem
+
+```ts
+import { walletAdapterToViemClient } from "@opensea/wallet-adapters/viem"
+import { base } from "viem/chains"
+
+const client = walletAdapterToViemClient(wallet, base, "https://mainnet.base.org")
+// Use as a standard viem WalletClient
+```
+
+### ethers.js
+
+```ts
+import { walletAdapterToEthersSigner } from "@opensea/wallet-adapters/ethers"
+
+const signer = walletAdapterToEthersSigner(wallet, provider)
+// Use as a standard ethers.js Signer
+```
+
+## Capabilities
+
+Each adapter declares its capabilities so consumers can check before calling:
+
+```ts
+if (wallet.capabilities.signMessage) {
+  const sig = await wallet.signMessage({ message: "hello" })
+}
+
+if (wallet.capabilities.managedGas) {
+  // No need to estimate gas — the provider handles it
+}
+```
+
+| Capability | Privy | Fireblocks | Turnkey | PrivateKey |
+|------------|-------|------------|---------|------------|
+| `signMessage` | true | true | true | true |
+| `signTypedData` | true | true | true | true |
+| `managedGas` | true | true | false | false |
+| `managedNonce` | true | true | false | false |
+
+## Observability
+
+Attach hooks for tracing and monitoring:
+
+```ts
+wallet.onRequest = (method, params) => {
+  console.log(`→ ${method}`, params)
+}
+wallet.onResponse = (method, result, durationMs) => {
+  console.log(`← ${method} (${durationMs}ms)`, result)
+}
+```
+
+## License
+
+MIT

package/dist/ethers.d.ts

@@ -0,0 +1,56 @@
+import { W as WalletAdapter } from './index-DqqC-Sa8.js';
+
+/**
+ * Bridge between WalletAdapter and ethers.js Signer.
+ *
+ * Creates an ethers.js AbstractSigner from any WalletAdapter, routing
+ * transaction signing through the adapter's signing backend.
+ *
+ * @example
+ * ```ts
+ * import { createWalletFromEnv } from "@opensea/wallet-adapters"
+ * import { walletAdapterToEthersSigner } from "@opensea/wallet-adapters/ethers"
+ * import { JsonRpcProvider } from "ethers"
+ *
+ * const adapter = createWalletFromEnv()
+ * const provider = new JsonRpcProvider("https://...")
+ * const signer = walletAdapterToEthersSigner(adapter, provider)
+ * ```
+ *
+ * ethers v6 is a peer dependency — consumers must install it separately.
+ */
+
+/**
+ * Create an ethers.js-compatible Signer from a WalletAdapter.
+ *
+ * Returns an object that implements the ethers.js Signer interface:
+ * - getAddress()
+ * - sendTransaction(tx)
+ * - signMessage(message) — only if adapter supports it
+ * - signTypedData(domain, types, value) — only if adapter supports it
+ */
+declare function walletAdapterToEthersSigner(adapter: WalletAdapter, provider: any): EthersAdapterSigner;
+declare class EthersAdapterSigner {
+    readonly adapter: WalletAdapter;
+    readonly provider: any;
+    constructor(adapter: WalletAdapter, provider: any);
+    getAddress(): Promise<string>;
+    sendTransaction(tx: {
+        to?: string;
+        data?: string;
+        value?: bigint | string;
+        chainId?: number | bigint;
+        gasLimit?: bigint | string;
+        maxFeePerGas?: bigint | string;
+        maxPriorityFeePerGas?: bigint | string;
+        nonce?: number;
+    }): Promise<{
+        hash: string;
+        wait: () => Promise<any>;
+    }>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    signTypedData(domain: Record<string, any>, types: Record<string, any>, value: Record<string, any>, primaryType?: string): Promise<string>;
+    connect(provider: any): EthersAdapterSigner;
+}
+
+export { EthersAdapterSigner, walletAdapterToEthersSigner };

package/dist/ethers.js

@@ -0,0 +1,62 @@
+// src/bridges/ethers.ts
+function walletAdapterToEthersSigner(adapter, provider) {
+  return new EthersAdapterSigner(adapter, provider);
+}
+var EthersAdapterSigner = class _EthersAdapterSigner {
+  adapter;
+  provider;
+  constructor(adapter, provider) {
+    this.adapter = adapter;
+    this.provider = provider;
+  }
+  async getAddress() {
+    return this.adapter.getAddress();
+  }
+  async sendTransaction(tx) {
+    const network = await this.provider.getNetwork();
+    const chainId = Number(tx.chainId ?? network.chainId);
+    const result = await this.adapter.sendTransaction({
+      to: tx.to ?? "",
+      data: tx.data ?? "0x",
+      value: tx.value ? String(BigInt(tx.value)) : "0",
+      chainId,
+      gas: tx.gasLimit ? String(BigInt(tx.gasLimit)) : void 0,
+      nonce: tx.nonce,
+      maxFeePerGas: tx.maxFeePerGas ? String(BigInt(tx.maxFeePerGas)) : void 0,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? String(BigInt(tx.maxPriorityFeePerGas)) : void 0
+    });
+    return {
+      hash: result.hash,
+      wait: () => this.provider.waitForTransaction(result.hash)
+    };
+  }
+  async signMessage(message) {
+    if (!this.adapter.signMessage) {
+      throw new Error(
+        `signMessage is not supported by the ${this.adapter.name} adapter`
+      );
+    }
+    return this.adapter.signMessage({ message });
+  }
+  async signTypedData(domain, types, value, primaryType) {
+    if (!this.adapter.signTypedData) {
+      throw new Error(
+        `signTypedData is not supported by the ${this.adapter.name} adapter`
+      );
+    }
+    return this.adapter.signTypedData({
+      domain,
+      types,
+      message: value,
+      primaryType: primaryType ?? Object.keys(types).find((t) => t !== "EIP712Domain") ?? ""
+    });
+  }
+  connect(provider) {
+    return new _EthersAdapterSigner(this.adapter, provider);
+  }
+};
+export {
+  EthersAdapterSigner,
+  walletAdapterToEthersSigner
+};
+//# sourceMappingURL=ethers.js.map

package/dist/ethers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bridges/ethers.ts"],"sourcesContent":["/**\n * Bridge between WalletAdapter and ethers.js Signer.\n *\n * Creates an ethers.js AbstractSigner from any WalletAdapter, routing\n * transaction signing through the adapter's signing backend.\n *\n * @example\n * ```ts\n * import { createWalletFromEnv } from \"@opensea/wallet-adapters\"\n * import { walletAdapterToEthersSigner } from \"@opensea/wallet-adapters/ethers\"\n * import { JsonRpcProvider } from \"ethers\"\n *\n * const adapter = createWalletFromEnv()\n * const provider = new JsonRpcProvider(\"https://...\")\n * const signer = walletAdapterToEthersSigner(adapter, provider)\n * ```\n *\n * ethers v6 is a peer dependency — consumers must install it separately.\n */\n\nimport type { WalletAdapter } from \"../types/index.js\"\n\n/**\n * Create an ethers.js-compatible Signer from a WalletAdapter.\n *\n * Returns an object that implements the ethers.js Signer interface:\n * - getAddress()\n * - sendTransaction(tx)\n * - signMessage(message) — only if adapter supports it\n * - signTypedData(domain, types, value) — only if adapter supports it\n */\nexport function walletAdapterToEthersSigner(\n  adapter: WalletAdapter,\n  provider: any,\n): EthersAdapterSigner {\n  return new EthersAdapterSigner(adapter, provider)\n}\n\nexport class EthersAdapterSigner {\n  readonly adapter: WalletAdapter\n  readonly provider: any\n\n  constructor(adapter: WalletAdapter, provider: any) {\n    this.adapter = adapter\n    this.provider = provider\n  }\n\n  async getAddress(): Promise<string> {\n    return this.adapter.getAddress()\n  }\n\n  async sendTransaction(tx: {\n    to?: string\n    data?: string\n    value?: bigint | string\n    chainId?: number | bigint\n    gasLimit?: bigint | string\n    maxFeePerGas?: bigint | string\n    maxPriorityFeePerGas?: bigint | string\n    nonce?: number\n  }): Promise<{ hash: string; wait: () => Promise<any> }> {\n    const network = await this.provider.getNetwork()\n    const chainId = Number(tx.chainId ?? network.chainId)\n\n    const result = await this.adapter.sendTransaction({\n      to: tx.to ?? \"\",\n      data: (tx.data as string) ?? \"0x\",\n      value: tx.value ? String(BigInt(tx.value)) : \"0\",\n      chainId,\n      gas: tx.gasLimit ? String(BigInt(tx.gasLimit)) : undefined,\n      nonce: tx.nonce,\n      maxFeePerGas: tx.maxFeePerGas\n        ? String(BigInt(tx.maxFeePerGas))\n        : undefined,\n      maxPriorityFeePerGas: tx.maxPriorityFeePerGas\n        ? String(BigInt(tx.maxPriorityFeePerGas))\n        : undefined,\n    })\n\n    return {\n      hash: result.hash,\n      wait: () => this.provider.waitForTransaction(result.hash),\n    }\n  }\n\n  async signMessage(message: string | Uint8Array): Promise<string> {\n    if (!this.adapter.signMessage) {\n      throw new Error(\n        `signMessage is not supported by the ${this.adapter.name} adapter`,\n      )\n    }\n    return this.adapter.signMessage({ message })\n  }\n\n  async signTypedData(\n    domain: Record<string, any>,\n    types: Record<string, any>,\n    value: Record<string, any>,\n    primaryType?: string,\n  ): Promise<string> {\n    if (!this.adapter.signTypedData) {\n      throw new Error(\n        `signTypedData is not supported by the ${this.adapter.name} adapter`,\n      )\n    }\n    // ethers.js uses \"value\" while our interface uses \"message\"\n    return this.adapter.signTypedData({\n      domain,\n      types,\n      message: value,\n      primaryType:\n        primaryType ?? Object.keys(types).find(t => t !== \"EIP712Domain\") ?? \"\",\n    })\n  }\n\n  connect(provider: any): EthersAdapterSigner {\n    return new EthersAdapterSigner(this.adapter, provider)\n  }\n}\n"],"mappings":";AA+BO,SAAS,4BACd,SACA,UACqB;AACrB,SAAO,IAAI,oBAAoB,SAAS,QAAQ;AAClD;AAEO,IAAM,sBAAN,MAAM,qBAAoB;AAAA,EACtB;AAAA,EACA;AAAA,EAET,YAAY,SAAwB,UAAe;AACjD,SAAK,UAAU;AACf,SAAK,WAAW;AAAA,EAClB;AAAA,EAEA,MAAM,aAA8B;AAClC,WAAO,KAAK,QAAQ,WAAW;AAAA,EACjC;AAAA,EAEA,MAAM,gBAAgB,IASkC;AACtD,UAAM,UAAU,MAAM,KAAK,SAAS,WAAW;AAC/C,UAAM,UAAU,OAAO,GAAG,WAAW,QAAQ,OAAO;AAEpD,UAAM,SAAS,MAAM,KAAK,QAAQ,gBAAgB;AAAA,MAChD,IAAI,GAAG,MAAM;AAAA,MACb,MAAO,GAAG,QAAmB;AAAA,MAC7B,OAAO,GAAG,QAAQ,OAAO,OAAO,GAAG,KAAK,CAAC,IAAI;AAAA,MAC7C;AAAA,MACA,KAAK,GAAG,WAAW,OAAO,OAAO,GAAG,QAAQ,CAAC,IAAI;AAAA,MACjD,OAAO,GAAG;AAAA,MACV,cAAc,GAAG,eACb,OAAO,OAAO,GAAG,YAAY,CAAC,IAC9B;AAAA,MACJ,sBAAsB,GAAG,uBACrB,OAAO,OAAO,GAAG,oBAAoB,CAAC,IACtC;AAAA,IACN,CAAC;AAED,WAAO;AAAA,MACL,MAAM,OAAO;AAAA,MACb,MAAM,MAAM,KAAK,SAAS,mBAAmB,OAAO,IAAI;AAAA,IAC1D;AAAA,EACF;AAAA,EAEA,MAAM,YAAY,SAA+C;AAC/D,QAAI,CAAC,KAAK,QAAQ,aAAa;AAC7B,YAAM,IAAI;AAAA,QACR,uCAAuC,KAAK,QAAQ,IAAI;AAAA,MAC1D;AAAA,IACF;AACA,WAAO,KAAK,QAAQ,YAAY,EAAE,QAAQ,CAAC;AAAA,EAC7C;AAAA,EAEA,MAAM,cACJ,QACA,OACA,OACA,aACiB;AACjB,QAAI,CAAC,KAAK,QAAQ,eAAe;AAC/B,YAAM,IAAI;AAAA,QACR,yCAAyC,KAAK,QAAQ,IAAI;AAAA,MAC5D;AAAA,IACF;AAEA,WAAO,KAAK,QAAQ,cAAc;AAAA,MAChC;AAAA,MACA;AAAA,MACA,SAAS;AAAA,MACT,aACE,eAAe,OAAO,KAAK,KAAK,EAAE,KAAK,OAAK,MAAM,cAAc,KAAK;AAAA,IACzE,CAAC;AAAA,EACH;AAAA,EAEA,QAAQ,UAAoC;AAC1C,WAAO,IAAI,qBAAoB,KAAK,SAAS,QAAQ;AAAA,EACvD;AACF;","names":[]}

package/dist/index-DqqC-Sa8.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Core types for the wallet adapter interface.
+ *
+ * These types define the contract between consumers and wallet providers.
+ * Designed to be provider-agnostic and extensible for future signing
+ * capabilities (EIP-712, EIP-191, batch transactions, etc.).
+ */
+interface TransactionRequest {
+    to: string;
+    data: string;
+    value: string;
+    chainId: number;
+    /** Pre-estimated gas limit (avoids redundant RPC call when provided) */
+    gas?: string;
+    /** Pre-fetched nonce */
+    nonce?: number;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+}
+interface TransactionResult {
+    hash: string;
+}
+interface SignMessageRequest {
+    message: string | Uint8Array;
+}
+interface SignTypedDataRequest {
+    domain: Record<string, unknown>;
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+/**
+ * Core wallet adapter interface.
+ *
+ * Implement this interface to add a new wallet provider. At minimum,
+ * a provider must support `getAddress()` and `sendTransaction()`.
+ * Optional capabilities (message signing, typed data signing) can be
+ * declared via the `capabilities` property.
+ */
+interface WalletAdapter {
+    /** Human-readable provider name for logging and error messages */
+    readonly name: string;
+    /** Declared capabilities of this adapter */
+    readonly capabilities: WalletCapabilities;
+    /** Get the wallet address */
+    getAddress(): Promise<string>;
+    /** Sign and send a transaction, returns the tx hash */
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+    /** Sign a raw message (EIP-191). Throws if not supported. */
+    signMessage?(request: SignMessageRequest): Promise<string>;
+    /** Sign EIP-712 typed data. Throws if not supported. */
+    signTypedData?(request: SignTypedDataRequest): Promise<string>;
+    /** Optional RPC URL for read operations (gas estimation, nonce, etc.) */
+    getRpcUrl?(): string;
+    /** Optional hook called before each adapter request (for metrics/logging) */
+    onRequest?: (method: string, params: unknown) => void;
+    /** Optional hook called after each adapter response (for metrics/logging) */
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+}
+/**
+ * Declares which optional operations an adapter supports.
+ * Consumers can check capabilities before calling optional methods.
+ */
+interface WalletCapabilities {
+    /** Whether signMessage() is supported */
+    signMessage: boolean;
+    /** Whether signTypedData() is supported (EIP-712) */
+    signTypedData: boolean;
+    /** Whether the provider manages gas estimation internally */
+    managedGas: boolean;
+    /** Whether the provider manages nonce internally */
+    managedNonce: boolean;
+}
+type WalletProvider = "privy" | "turnkey" | "fireblocks" | "private-key";
+declare const WALLET_PROVIDERS: WalletProvider[];
+
+export { type SignMessageRequest as S, type TransactionRequest as T, type WalletAdapter as W, type WalletCapabilities as a, type TransactionResult as b, type SignTypedDataRequest as c, type WalletProvider as d, WALLET_PROVIDERS as e };

package/dist/index.d.ts

@@ -0,0 +1,198 @@
+import { W as WalletAdapter, a as WalletCapabilities, T as TransactionRequest, b as TransactionResult, S as SignMessageRequest, c as SignTypedDataRequest, d as WalletProvider } from './index-DqqC-Sa8.js';
+export { e as WALLET_PROVIDERS } from './index-DqqC-Sa8.js';
+
+/**
+ * Fireblocks wallet adapter.
+ *
+ * Uses Fireblocks' REST API to sign and send transactions through their
+ * enterprise-grade MPC custody infrastructure.
+ *
+ * Required environment variables:
+ *   FIREBLOCKS_API_KEY       — Fireblocks API key
+ *   FIREBLOCKS_API_SECRET    — Fireblocks API secret (RSA private key, PEM-encoded)
+ *   FIREBLOCKS_VAULT_ID      — Fireblocks vault account ID
+ *
+ * Optional:
+ *   FIREBLOCKS_API_BASE_URL       — Override the API base URL
+ *   FIREBLOCKS_ASSET_ID           — Override the Fireblocks asset ID
+ *   FIREBLOCKS_MAX_POLL_ATTEMPTS  — Override max polling attempts (default: 60 = 120s)
+ *
+ * @see https://developers.fireblocks.com/docs/introduction
+ */
+
+/** Map EVM chain IDs to Fireblocks asset IDs. */
+declare const CHAIN_TO_FIREBLOCKS_ASSET: Record<number, string>;
+interface FireblocksConfig {
+    apiKey: string;
+    apiSecret: string;
+    vaultId: string;
+    assetId?: string;
+    baseUrl?: string;
+    maxPollAttempts?: number;
+}
+declare class FireblocksAdapter implements WalletAdapter {
+    readonly name = "fireblocks";
+    readonly capabilities: WalletCapabilities;
+    onRequest?: (method: string, params: unknown) => void;
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+    private config;
+    private cachedAddress?;
+    constructor(config: FireblocksConfig);
+    static fromEnv(): FireblocksAdapter;
+    private get baseUrl();
+    private createJwt;
+    private pemToBuffer;
+    private hashBody;
+    private resolveAssetId;
+    getAddress(): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+    signMessage(request: SignMessageRequest): Promise<string>;
+    signTypedData(request: SignTypedDataRequest): Promise<string>;
+    private signRawMessage;
+    private waitForSignature;
+    private waitForTransaction;
+}
+
+/**
+ * Private key wallet adapter.
+ *
+ * Signs and sends transactions using a raw private key with secp256k1.
+ *
+ * Intended for development and testing. For production use, prefer a
+ * managed wallet provider (Privy, Turnkey, Fireblocks).
+ *
+ * Required environment variables:
+ *   PRIVATE_KEY — Hex-encoded private key (with or without 0x prefix)
+ *   RPC_URL    — JSON-RPC endpoint for broadcasting and gas estimation
+ *
+ * Optional:
+ *   WALLET_ADDRESS — Pre-computed address (skips derivation)
+ */
+
+interface PrivateKeyConfig {
+    privateKey: string;
+    rpcUrl: string;
+    address?: string;
+}
+declare class PrivateKeyAdapter implements WalletAdapter {
+    readonly name = "private-key";
+    readonly capabilities: WalletCapabilities;
+    onRequest?: (method: string, params: unknown) => void;
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+    private config;
+    private cachedAddress?;
+    constructor(config: PrivateKeyConfig);
+    static fromEnv(): PrivateKeyAdapter;
+    getRpcUrl(): string;
+    getAddress(): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+    signMessage(request: SignMessageRequest): Promise<string>;
+    signTypedData(request: SignTypedDataRequest): Promise<string>;
+    private rpcCall;
+}
+
+/**
+ * Privy wallet adapter.
+ *
+ * Uses Privy's server-side wallet API to sign and send transactions.
+ * Transactions are governed by Privy's programmable policy engine —
+ * policies are evaluated in a trusted execution environment before signing.
+ *
+ * Required environment variables:
+ *   PRIVY_APP_ID      — Privy application ID
+ *   PRIVY_APP_SECRET  — Privy application secret
+ *   PRIVY_WALLET_ID   — Wallet ID to use for signing
+ *
+ * Optional:
+ *   PRIVY_API_BASE_URL — Override the Privy API base URL
+ *
+ * @see https://docs.privy.io/wallets/wallets/server-side-access
+ * @see https://docs.privy.io/controls/policies/overview
+ */
+
+interface PrivyConfig {
+    appId: string;
+    appSecret: string;
+    walletId: string;
+    baseUrl?: string;
+}
+declare class PrivyAdapter implements WalletAdapter {
+    readonly name = "privy";
+    readonly capabilities: WalletCapabilities;
+    onRequest?: (method: string, params: unknown) => void;
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+    private config;
+    private cachedAddress?;
+    constructor(config: PrivyConfig);
+    static fromEnv(): PrivyAdapter;
+    private get baseUrl();
+    private get authHeaders();
+    getAddress(): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+    signMessage(request: SignMessageRequest): Promise<string>;
+    signTypedData(request: SignTypedDataRequest): Promise<string>;
+}
+
+/**
+ * Turnkey wallet adapter.
+ *
+ * Uses Turnkey's API to sign and send transactions via HSM-backed
+ * signing infrastructure. Authentication uses Turnkey's stamp scheme:
+ * each request body is hashed and signed with a P-256 ECDSA key.
+ *
+ * Required environment variables:
+ *   TURNKEY_API_PUBLIC_KEY   — Turnkey API public key (hex-encoded)
+ *   TURNKEY_API_PRIVATE_KEY  — Turnkey API private key (hex-encoded P-256)
+ *   TURNKEY_ORGANIZATION_ID  — Turnkey organization ID
+ *   TURNKEY_WALLET_ADDRESS   — Ethereum address managed by Turnkey
+ *   TURNKEY_RPC_URL          — RPC endpoint for gas estimation and broadcast
+ *
+ * Optional:
+ *   TURNKEY_API_BASE_URL   — Override the Turnkey API base URL
+ *   TURNKEY_PRIVATE_KEY_ID — Turnkey private key ID (for signing with a specific key)
+ *
+ * @see https://docs.turnkey.com/
+ */
+
+interface TurnkeyConfig {
+    apiPublicKey: string;
+    apiPrivateKey: string;
+    organizationId: string;
+    walletAddress: string;
+    rpcUrl: string;
+    privateKeyId?: string;
+    baseUrl?: string;
+}
+declare class TurnkeyAdapter implements WalletAdapter {
+    readonly name = "turnkey";
+    readonly capabilities: WalletCapabilities;
+    onRequest?: (method: string, params: unknown) => void;
+    onResponse?: (method: string, result: unknown, durationMs: number) => void;
+    private config;
+    constructor(config: TurnkeyConfig);
+    static fromEnv(): TurnkeyAdapter;
+    getRpcUrl(): string;
+    private get baseUrl();
+    private stamp;
+    private signedRequest;
+    getAddress(): Promise<string>;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResult>;
+    signMessage(request: SignMessageRequest): Promise<string>;
+    signTypedData(request: SignTypedDataRequest): Promise<string>;
+    private signRawPayload;
+    private estimateGasParams;
+    private rpcCall;
+}
+
+/**
+ * Auto-detection factory that creates a WalletAdapter based on
+ * which environment variables are present.
+ *
+ * Priority: Privy > Fireblocks > Turnkey > PrivateKey
+ */
+
+declare function createWalletFromEnv(): WalletAdapter;
+declare function createWalletForProvider(provider: WalletProvider): WalletAdapter;
+declare function detectProvider(): WalletProvider | null;
+
+export { CHAIN_TO_FIREBLOCKS_ASSET, FireblocksAdapter, type FireblocksConfig, PrivateKeyAdapter, type PrivateKeyConfig, PrivyAdapter, type PrivyConfig, SignMessageRequest, SignTypedDataRequest, TransactionRequest, TransactionResult, TurnkeyAdapter, type TurnkeyConfig, WalletAdapter, WalletCapabilities, WalletProvider, createWalletForProvider, createWalletFromEnv, detectProvider };