@opensea/wallet-adapters 0.1.0

package/dist/index.js

@@ -0,0 +1,1376 @@
+// src/util/eip712.ts
+import { keccak_256 } from "@noble/hashes/sha3.js";
+function hashTypedData(domain, primaryType, message, types) {
+  const domainSeparator = hashStruct("EIP712Domain", domain, {
+    ...types,
+    EIP712Domain: buildDomainType(domain)
+  });
+  const messageHash = hashStruct(primaryType, message, types);
+  const packed = new Uint8Array(66);
+  packed[0] = 25;
+  packed[1] = 1;
+  packed.set(domainSeparator, 2);
+  packed.set(messageHash, 34);
+  return keccak_256(packed);
+}
+function hashPersonalMessage(message) {
+  const msgBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+  const prefix = new TextEncoder().encode(
+    `Ethereum Signed Message:
+${msgBytes.length}`
+  );
+  const payload = new Uint8Array(prefix.length + msgBytes.length);
+  payload.set(prefix, 0);
+  payload.set(msgBytes, prefix.length);
+  return keccak_256(payload);
+}
+function buildDomainType(domain) {
+  const fields = [];
+  if ("name" in domain) fields.push({ name: "name", type: "string" });
+  if ("version" in domain) fields.push({ name: "version", type: "string" });
+  if ("chainId" in domain) fields.push({ name: "chainId", type: "uint256" });
+  if ("verifyingContract" in domain)
+    fields.push({ name: "verifyingContract", type: "address" });
+  if ("salt" in domain) fields.push({ name: "salt", type: "bytes32" });
+  return fields;
+}
+function hashStruct(primaryType, data, types) {
+  const typeHash = hashType(primaryType, types);
+  const encodedValues = encodeData(primaryType, data, types);
+  const combined = new Uint8Array(32 + encodedValues.length);
+  combined.set(typeHash, 0);
+  combined.set(encodedValues, 32);
+  return keccak_256(combined);
+}
+function hashType(primaryType, types) {
+  return keccak_256(new TextEncoder().encode(encodeType(primaryType, types)));
+}
+function encodeType(primaryType, types) {
+  const fields = types[primaryType];
+  if (!fields) throw new Error(`Unknown type: ${primaryType}`);
+  const deps = /* @__PURE__ */ new Set();
+  findTypeDeps(primaryType, types, deps);
+  deps.delete(primaryType);
+  const sorted = [...deps].sort();
+  let result = `${primaryType}(${fields.map((f) => `${f.type} ${f.name}`).join(",")})`;
+  for (const dep of sorted) {
+    const depFields = types[dep];
+    if (depFields) {
+      result += `${dep}(${depFields.map((f) => `${f.type} ${f.name}`).join(",")})`;
+    }
+  }
+  return result;
+}
+function findTypeDeps(type, types, deps) {
+  if (deps.has(type)) return;
+  const fields = types[type];
+  if (!fields) return;
+  deps.add(type);
+  for (const field of fields) {
+    const baseType = field.type.replace(/\[\d*\]$/, "");
+    if (types[baseType]) {
+      findTypeDeps(baseType, types, deps);
+    }
+  }
+}
+function encodeData(primaryType, data, types) {
+  const fields = types[primaryType];
+  if (!fields) throw new Error(`Unknown type: ${primaryType}`);
+  const chunks = [];
+  for (const field of fields) {
+    const value = data[field.name];
+    chunks.push(encodeValue(field.type, value, types));
+  }
+  const result = new Uint8Array(chunks.length * 32);
+  for (let i = 0; i < chunks.length; i++) {
+    result.set(chunks[i], i * 32);
+  }
+  return result;
+}
+function encodeValue(type, value, types) {
+  if (type === "string") {
+    return keccak_256(new TextEncoder().encode(value));
+  }
+  if (type === "bytes") {
+    const v = value;
+    const bytes = hexToBytes(v.startsWith("0x") ? v.slice(2) : v);
+    return keccak_256(bytes);
+  }
+  if (type.endsWith("]")) {
+    const baseType = type.replace(/\[\d*\]$/, "");
+    const arr = value;
+    const encoded = arr.map((item) => encodeValue(baseType, item, types));
+    const flat = new Uint8Array(encoded.length * 32);
+    for (let i = 0; i < encoded.length; i++) flat.set(encoded[i], i * 32);
+    return keccak_256(flat);
+  }
+  if (types[type]) {
+    return hashStruct(type, value, types);
+  }
+  if (type === "address") {
+    const addr = value.toLowerCase().replace("0x", "");
+    const padded = new Uint8Array(32);
+    padded.set(hexToBytes(addr.padStart(40, "0")), 12);
+    return padded;
+  }
+  if (type === "bool") {
+    const padded = new Uint8Array(32);
+    padded[31] = value ? 1 : 0;
+    return padded;
+  }
+  if (type.startsWith("uint") || type.startsWith("int")) {
+    const padded = new Uint8Array(32);
+    const n = BigInt(value);
+    const hex = (n < 0n ? n + (1n << 256n) : n).toString(16).padStart(64, "0");
+    padded.set(hexToBytes(hex), 0);
+    return padded;
+  }
+  if (type.startsWith("bytes")) {
+    const v = value;
+    const bytes = hexToBytes(v.startsWith("0x") ? v.slice(2) : v);
+    const padded = new Uint8Array(32);
+    padded.set(bytes, 0);
+    return padded;
+  }
+  throw new Error(`Unsupported EIP-712 type: ${type}`);
+}
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+
+// src/adapters/fireblocks.ts
+var CHAIN_TO_FIREBLOCKS_ASSET = {
+  1: "ETH",
+  10: "ETH-OPT",
+  130: "UNICHAIN_ETH",
+  137: "MATIC_POLYGON",
+  360: "SHAPE_ETH",
+  1329: "SEI_EVM",
+  1868: "SONEIUM_ETH",
+  2741: "ABSTRACT_ETH",
+  8453: "BASECHAIN_ETH",
+  33139: "APE_CHAIN",
+  42161: "ETH-AETH",
+  43114: "AVAX",
+  80094: "BERA_CHAIN",
+  81457: "BLAST_ETH",
+  7777777: "ZORA_ETH"
+};
+var FIREBLOCKS_API_BASE = "https://api.fireblocks.io";
+var FireblocksAdapter = class _FireblocksAdapter {
+  name = "fireblocks";
+  capabilities = {
+    signMessage: true,
+    signTypedData: true,
+    managedGas: true,
+    managedNonce: true
+  };
+  onRequest;
+  onResponse;
+  config;
+  cachedAddress;
+  constructor(config) {
+    this.config = config;
+  }
+  static fromEnv() {
+    const apiKey = process.env.FIREBLOCKS_API_KEY;
+    const apiSecret = process.env.FIREBLOCKS_API_SECRET;
+    const vaultId = process.env.FIREBLOCKS_VAULT_ID;
+    if (!apiKey) {
+      throw new Error("FIREBLOCKS_API_KEY environment variable is required");
+    }
+    if (!apiSecret) {
+      throw new Error("FIREBLOCKS_API_SECRET environment variable is required");
+    }
+    if (!vaultId) {
+      throw new Error("FIREBLOCKS_VAULT_ID environment variable is required");
+    }
+    const maxPollAttempts = process.env.FIREBLOCKS_MAX_POLL_ATTEMPTS ? Number.parseInt(process.env.FIREBLOCKS_MAX_POLL_ATTEMPTS, 10) : void 0;
+    return new _FireblocksAdapter({
+      apiKey,
+      apiSecret,
+      vaultId,
+      assetId: process.env.FIREBLOCKS_ASSET_ID,
+      baseUrl: process.env.FIREBLOCKS_API_BASE_URL,
+      maxPollAttempts
+    });
+  }
+  get baseUrl() {
+    return this.config.baseUrl ?? FIREBLOCKS_API_BASE;
+  }
+  async createJwt(path, bodyHash) {
+    const now = Math.floor(Date.now() / 1e3);
+    const header = { alg: "RS256", typ: "JWT" };
+    const payload = {
+      uri: path,
+      nonce: crypto.randomUUID(),
+      iat: now,
+      exp: now + 30,
+      sub: this.config.apiKey,
+      bodyHash
+    };
+    const b64url = (obj) => Buffer.from(JSON.stringify(obj)).toString("base64url");
+    const unsigned = `${b64url(header)}.${b64url(payload)}`;
+    const key = await crypto.subtle.importKey(
+      "pkcs8",
+      this.pemToBuffer(this.config.apiSecret),
+      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const sig = await crypto.subtle.sign(
+      "RSASSA-PKCS1-v1_5",
+      key,
+      new TextEncoder().encode(unsigned)
+    );
+    return `${unsigned}.${Buffer.from(sig).toString("base64url")}`;
+  }
+  pemToBuffer(pem) {
+    const lines = pem.replace(/-----BEGIN .*-----/, "").replace(/-----END .*-----/, "").replace(/\s/g, "");
+    const buf = Buffer.from(lines, "base64");
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  async hashBody(body) {
+    const hash = await crypto.subtle.digest(
+      "SHA-256",
+      new TextEncoder().encode(body)
+    );
+    return Buffer.from(hash).toString("hex");
+  }
+  resolveAssetId(chainId) {
+    if (this.config.assetId) return this.config.assetId;
+    const asset = CHAIN_TO_FIREBLOCKS_ASSET[chainId];
+    if (!asset) {
+      throw new Error(
+        `No Fireblocks asset ID mapping for chain ${chainId}. Set FIREBLOCKS_ASSET_ID explicitly or use a supported chain: ${Object.keys(CHAIN_TO_FIREBLOCKS_ASSET).join(", ")}`
+      );
+    }
+    return asset;
+  }
+  async getAddress() {
+    if (this.cachedAddress) return this.cachedAddress;
+    const assetId = this.config.assetId ?? "ETH";
+    const path = `/v1/vault/accounts/${this.config.vaultId}/${assetId}/addresses`;
+    const bodyHash = await this.hashBody("");
+    const jwt = await this.createJwt(path, bodyHash);
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      headers: {
+        "X-API-Key": this.config.apiKey,
+        Authorization: `Bearer ${jwt}`
+      }
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Fireblocks getAddress failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    if (!data[0]?.address) {
+      throw new Error("Fireblocks returned no addresses for vault");
+    }
+    this.cachedAddress = data[0].address;
+    return data[0].address;
+  }
+  async sendTransaction(tx) {
+    this.onRequest?.("sendTransaction", tx);
+    const startTime = Date.now();
+    const assetId = this.resolveAssetId(tx.chainId);
+    const path = "/v1/transactions";
+    const requestBody = {
+      assetId,
+      operation: "CONTRACT_CALL",
+      source: {
+        type: "VAULT_ACCOUNT",
+        id: this.config.vaultId
+      },
+      destination: {
+        type: "ONE_TIME_ADDRESS",
+        oneTimeAddress: { address: tx.to }
+      },
+      amount: tx.value === "0" ? "0" : tx.value,
+      extraParameters: {
+        contractCallData: tx.data
+      }
+    };
+    const bodyStr = JSON.stringify(requestBody);
+    const bodyHash = await this.hashBody(bodyStr);
+    const jwt = await this.createJwt(path, bodyHash);
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey,
+        Authorization: `Bearer ${jwt}`
+      },
+      body: bodyStr
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Fireblocks sendTransaction failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    if (data.txHash) {
+      const result2 = { hash: data.txHash };
+      this.onResponse?.("sendTransaction", result2, Date.now() - startTime);
+      return result2;
+    }
+    const result = await this.waitForTransaction(data.id);
+    this.onResponse?.("sendTransaction", result, Date.now() - startTime);
+    return result;
+  }
+  async signMessage(request) {
+    this.onRequest?.("signMessage", request);
+    const startTime = Date.now();
+    const hash = Buffer.from(hashPersonalMessage(request.message)).toString(
+      "hex"
+    );
+    const signature = await this.signRawMessage(hash);
+    this.onResponse?.("signMessage", signature, Date.now() - startTime);
+    return signature;
+  }
+  async signTypedData(request) {
+    this.onRequest?.("signTypedData", request);
+    const startTime = Date.now();
+    const hash = Buffer.from(
+      hashTypedData(
+        request.domain,
+        request.primaryType,
+        request.message,
+        request.types
+      )
+    ).toString("hex");
+    const signature = await this.signRawMessage(hash);
+    this.onResponse?.("signTypedData", signature, Date.now() - startTime);
+    return signature;
+  }
+  async signRawMessage(hashHex) {
+    const path = "/v1/transactions";
+    const requestBody = {
+      assetId: this.config.assetId ?? "ETH",
+      operation: "RAW",
+      source: {
+        type: "VAULT_ACCOUNT",
+        id: this.config.vaultId
+      },
+      extraParameters: {
+        rawMessageData: {
+          messages: [
+            {
+              content: hashHex
+            }
+          ]
+        }
+      }
+    };
+    const bodyStr = JSON.stringify(requestBody);
+    const bodyHash = await this.hashBody(bodyStr);
+    const jwt = await this.createJwt(path, bodyHash);
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey,
+        Authorization: `Bearer ${jwt}`
+      },
+      body: bodyStr
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Fireblocks signRawMessage failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    return this.waitForSignature(data.id);
+  }
+  async waitForSignature(txId) {
+    const maxAttempts = this.config.maxPollAttempts ?? 60;
+    const pollIntervalMs = 2e3;
+    for (let i = 0; i < maxAttempts; i++) {
+      const path = `/v1/transactions/${txId}`;
+      const bodyHash = await this.hashBody("");
+      const jwt = await this.createJwt(path, bodyHash);
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        headers: {
+          "X-API-Key": this.config.apiKey,
+          Authorization: `Bearer ${jwt}`
+        }
+      });
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(
+          `Fireblocks signature poll failed (${response.status}): ${body}`
+        );
+      }
+      const data = await response.json();
+      if (data.status === "COMPLETED" && data.signedMessages?.[0]) {
+        const { r, s, v } = data.signedMessages[0].signature;
+        const rHex = r.padStart(64, "0");
+        const sHex = s.padStart(64, "0");
+        const vHex = (v + 27).toString(16).padStart(2, "0");
+        return `0x${rHex}${sHex}${vHex}`;
+      }
+      if (data.status === "FAILED" || data.status === "REJECTED" || data.status === "CANCELLED" || data.status === "BLOCKED") {
+        throw new Error(
+          `Fireblocks signing ${txId} ended with status: ${data.status}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error(
+      `Fireblocks signing ${txId} did not complete within ${maxAttempts * pollIntervalMs / 1e3}s`
+    );
+  }
+  async waitForTransaction(txId) {
+    const maxAttempts = this.config.maxPollAttempts ?? 60;
+    const pollIntervalMs = 2e3;
+    for (let i = 0; i < maxAttempts; i++) {
+      const path = `/v1/transactions/${txId}`;
+      const bodyHash = await this.hashBody("");
+      const jwt = await this.createJwt(path, bodyHash);
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        headers: {
+          "X-API-Key": this.config.apiKey,
+          Authorization: `Bearer ${jwt}`
+        }
+      });
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Fireblocks poll failed (${response.status}): ${body}`);
+      }
+      const data = await response.json();
+      if (data.status === "COMPLETED" && data.txHash) {
+        return { hash: data.txHash };
+      }
+      if (data.status === "FAILED" || data.status === "REJECTED" || data.status === "CANCELLED" || data.status === "BLOCKED") {
+        throw new Error(
+          `Fireblocks transaction ${txId} ended with status: ${data.status}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error(
+      `Fireblocks transaction ${txId} did not complete within ${maxAttempts * pollIntervalMs / 1e3}s`
+    );
+  }
+};
+
+// src/adapters/private-key.ts
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { keccak_256 as keccak_2562 } from "@noble/hashes/sha3.js";
+import { bytesToHex as nobleToHex } from "@noble/hashes/utils.js";
+
+// src/adapters/turnkey.ts
+var TURNKEY_API_BASE = "https://api.turnkey.com";
+var TurnkeyAdapter = class _TurnkeyAdapter {
+  name = "turnkey";
+  capabilities = {
+    signMessage: true,
+    signTypedData: true,
+    managedGas: false,
+    managedNonce: false
+  };
+  onRequest;
+  onResponse;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  static fromEnv() {
+    const apiPublicKey = process.env.TURNKEY_API_PUBLIC_KEY;
+    const apiPrivateKey = process.env.TURNKEY_API_PRIVATE_KEY;
+    const organizationId = process.env.TURNKEY_ORGANIZATION_ID;
+    const walletAddress = process.env.TURNKEY_WALLET_ADDRESS;
+    if (!apiPublicKey) {
+      throw new Error("TURNKEY_API_PUBLIC_KEY environment variable is required");
+    }
+    if (!apiPrivateKey) {
+      throw new Error(
+        "TURNKEY_API_PRIVATE_KEY environment variable is required"
+      );
+    }
+    if (!organizationId) {
+      throw new Error(
+        "TURNKEY_ORGANIZATION_ID environment variable is required"
+      );
+    }
+    if (!walletAddress) {
+      throw new Error("TURNKEY_WALLET_ADDRESS environment variable is required");
+    }
+    const rpcUrl = process.env.TURNKEY_RPC_URL;
+    if (!rpcUrl) {
+      throw new Error(
+        "TURNKEY_RPC_URL environment variable is required. It is used for gas estimation and transaction broadcasting."
+      );
+    }
+    return new _TurnkeyAdapter({
+      apiPublicKey,
+      apiPrivateKey,
+      organizationId,
+      walletAddress,
+      rpcUrl,
+      privateKeyId: process.env.TURNKEY_PRIVATE_KEY_ID,
+      baseUrl: process.env.TURNKEY_API_BASE_URL
+    });
+  }
+  getRpcUrl() {
+    return this.config.rpcUrl;
+  }
+  get baseUrl() {
+    return this.config.baseUrl ?? TURNKEY_API_BASE;
+  }
+  async stamp(body) {
+    const encoder = new TextEncoder();
+    const bodyHash = await crypto.subtle.digest("SHA-256", encoder.encode(body));
+    const keyData = hexToBytes2(this.config.apiPrivateKey);
+    const cryptoKey = await crypto.subtle.importKey(
+      "pkcs8",
+      derEncodeP256PrivateKey(keyData),
+      { name: "ECDSA", namedCurve: "P-256" },
+      false,
+      ["sign"]
+    );
+    const p1363Sig = await crypto.subtle.sign(
+      { name: "ECDSA", hash: "SHA-256" },
+      cryptoKey,
+      bodyHash
+    );
+    const derSig = p1363ToDer(new Uint8Array(p1363Sig));
+    const signatureHex = bytesToHex(derSig);
+    const stampJson = JSON.stringify({
+      publicKey: this.config.apiPublicKey,
+      scheme: "SIGNATURE_SCHEME_TK_API_P256",
+      signature: signatureHex
+    });
+    return Buffer.from(stampJson).toString("base64url");
+  }
+  async signedRequest(path, body) {
+    const bodyStr = JSON.stringify(body);
+    const stampValue = await this.stamp(bodyStr);
+    return fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Stamp": stampValue
+      },
+      body: bodyStr
+    });
+  }
+  async getAddress() {
+    return this.config.walletAddress;
+  }
+  async sendTransaction(tx) {
+    this.onRequest?.("sendTransaction", tx);
+    const startTime = Date.now();
+    const { rpcUrl } = this.config;
+    const gasParams = await this.estimateGasParams(rpcUrl, tx);
+    const rlpHex = rlpEncodeEip1559Tx({
+      chainId: tx.chainId,
+      nonce: gasParams.nonce,
+      maxPriorityFeePerGas: gasParams.maxPriorityFeePerGas,
+      maxFeePerGas: gasParams.maxFeePerGas,
+      gasLimit: gasParams.gasLimit,
+      to: tx.to,
+      data: tx.data,
+      value: tx.value
+    });
+    const signWith = this.config.privateKeyId ?? this.config.walletAddress;
+    const response = await this.signedRequest(
+      "/public/v1/submit/sign_transaction",
+      {
+        type: "ACTIVITY_TYPE_SIGN_TRANSACTION_V2",
+        organizationId: this.config.organizationId,
+        timestampMs: Date.now().toString(),
+        parameters: {
+          signWith,
+          type: "TRANSACTION_TYPE_ETHEREUM",
+          unsignedTransaction: rlpHex
+        }
+      }
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Turnkey sendTransaction failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    const signedTx = data.activity.result?.signTransactionResult?.signedTransaction;
+    if (!signedTx) {
+      throw new Error(
+        `Turnkey sign transaction did not return a signed payload (activity status: ${data.activity.status})`
+      );
+    }
+    const rpcResponse = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "eth_sendRawTransaction",
+        params: [signedTx]
+      })
+    });
+    if (!rpcResponse.ok) {
+      const rpcBody = await rpcResponse.text();
+      throw new Error(
+        `Turnkey broadcast failed (${rpcResponse.status}): ${rpcBody}`
+      );
+    }
+    const rpcData = await rpcResponse.json();
+    if (rpcData.error) {
+      throw new Error(`Turnkey broadcast RPC error: ${rpcData.error.message}`);
+    }
+    if (!rpcData.result) {
+      throw new Error("Turnkey broadcast returned no tx hash");
+    }
+    const result = { hash: rpcData.result };
+    this.onResponse?.("sendTransaction", result, Date.now() - startTime);
+    return result;
+  }
+  async signMessage(request) {
+    this.onRequest?.("signMessage", request);
+    const startTime = Date.now();
+    const hash = bytesToHex(hashPersonalMessage(request.message));
+    const signature = await this.signRawPayload(hash);
+    this.onResponse?.("signMessage", signature, Date.now() - startTime);
+    return signature;
+  }
+  async signTypedData(request) {
+    this.onRequest?.("signTypedData", request);
+    const startTime = Date.now();
+    const hash = bytesToHex(
+      hashTypedData(
+        request.domain,
+        request.primaryType,
+        request.message,
+        request.types
+      )
+    );
+    const signature = await this.signRawPayload(hash);
+    this.onResponse?.("signTypedData", signature, Date.now() - startTime);
+    return signature;
+  }
+  async signRawPayload(hashHex) {
+    const signWith = this.config.privateKeyId ?? this.config.walletAddress;
+    const response = await this.signedRequest(
+      "/public/v1/submit/sign_raw_payload",
+      {
+        type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+        organizationId: this.config.organizationId,
+        timestampMs: Date.now().toString(),
+        parameters: {
+          signWith,
+          payload: hashHex,
+          encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+          hashFunction: "HASH_FUNCTION_NO_OP"
+        }
+      }
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Turnkey signRawPayload failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    const sigResult = data.activity.result?.signRawPayloadResult;
+    if (!sigResult) {
+      throw new Error(
+        `Turnkey sign raw payload did not return a result (status: ${data.activity.status})`
+      );
+    }
+    const r = sigResult.r.padStart(64, "0");
+    const s = sigResult.s.padStart(64, "0");
+    const vNum = Number.parseInt(sigResult.v, 16) + 27;
+    const v = vNum.toString(16).padStart(2, "0");
+    return `0x${r}${s}${v}`;
+  }
+  async estimateGasParams(rpcUrl, tx) {
+    if (tx.gas && tx.nonce !== void 0 && tx.maxFeePerGas) {
+      return {
+        nonce: BigInt(tx.nonce),
+        gasLimit: BigInt(tx.gas),
+        maxFeePerGas: BigInt(tx.maxFeePerGas),
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? BigInt(tx.maxPriorityFeePerGas) : 1500000000n
+      };
+    }
+    const from = this.config.walletAddress;
+    const txValue = tx.value === "0" ? "0x0" : `0x${BigInt(tx.value).toString(16)}`;
+    const [nonceResult, gasEstimateResult, feeDataResult] = await Promise.all([
+      this.rpcCall(rpcUrl, "eth_getTransactionCount", [from, "pending"]),
+      this.rpcCall(rpcUrl, "eth_estimateGas", [
+        {
+          from,
+          to: tx.to,
+          data: tx.data || "0x",
+          value: txValue
+        }
+      ]),
+      this.rpcCall(rpcUrl, "eth_feeHistory", [1, "latest", [50]])
+    ]);
+    const nonce = BigInt(nonceResult);
+    const rawGasLimit = BigInt(gasEstimateResult);
+    const gasLimit = rawGasLimit * 120n / 100n;
+    const feeHistory = feeDataResult;
+    const latestBaseFee = BigInt(
+      feeHistory.baseFeePerGas[1] ?? feeHistory.baseFeePerGas[0]
+    );
+    const maxPriorityFeePerGas = feeHistory.reward?.[0]?.[0] ? BigInt(feeHistory.reward[0][0]) : 1500000000n;
+    const maxFeePerGas = latestBaseFee * 2n + maxPriorityFeePerGas;
+    return { nonce, gasLimit, maxFeePerGas, maxPriorityFeePerGas };
+  }
+  async rpcCall(rpcUrl, method, params) {
+    const response = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method,
+        params
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Turnkey RPC ${method} failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Turnkey RPC ${method} error: ${data.error.message}`);
+    }
+    return data.result;
+  }
+};
+function rlpEncodeEip1559Tx(tx) {
+  const chainIdBytes = bigIntToBytes(BigInt(tx.chainId));
+  const nonce = bigIntToBytes(tx.nonce);
+  const maxPriorityFeePerGas = bigIntToBytes(tx.maxPriorityFeePerGas);
+  const maxFeePerGas = bigIntToBytes(tx.maxFeePerGas);
+  const gasLimit = bigIntToBytes(tx.gasLimit);
+  const toBytes = hexToBytes2(tx.to);
+  const valueBytes = tx.value === "0" ? new Uint8Array(0) : bigIntToBytes(BigInt(tx.value));
+  const dataBytes = tx.data ? hexToBytes2(tx.data) : new Uint8Array(0);
+  const fields = [
+    rlpEncodeBytes(chainIdBytes),
+    rlpEncodeBytes(nonce),
+    rlpEncodeBytes(maxPriorityFeePerGas),
+    rlpEncodeBytes(maxFeePerGas),
+    rlpEncodeBytes(gasLimit),
+    rlpEncodeBytes(toBytes),
+    rlpEncodeBytes(valueBytes),
+    rlpEncodeBytes(dataBytes),
+    rlpEncodeList([])
+  ];
+  const rlpList = rlpEncodeList(fields);
+  const result = new Uint8Array(1 + rlpList.length);
+  result[0] = 2;
+  result.set(rlpList, 1);
+  return bytesToHex(result);
+}
+function rlpEncodeBytes(bytes) {
+  if (bytes.length === 1 && bytes[0] < 128) {
+    return bytes;
+  }
+  if (bytes.length === 0) {
+    return new Uint8Array([128]);
+  }
+  if (bytes.length <= 55) {
+    const result2 = new Uint8Array(1 + bytes.length);
+    result2[0] = 128 + bytes.length;
+    result2.set(bytes, 1);
+    return result2;
+  }
+  const lenBytes = bigIntToBytes(BigInt(bytes.length));
+  const result = new Uint8Array(1 + lenBytes.length + bytes.length);
+  result[0] = 183 + lenBytes.length;
+  result.set(lenBytes, 1);
+  result.set(bytes, 1 + lenBytes.length);
+  return result;
+}
+function rlpEncodeList(items) {
+  let totalLen = 0;
+  for (const item of items) totalLen += item.length;
+  if (totalLen <= 55) {
+    const result2 = new Uint8Array(1 + totalLen);
+    result2[0] = 192 + totalLen;
+    let offset2 = 1;
+    for (const item of items) {
+      result2.set(item, offset2);
+      offset2 += item.length;
+    }
+    return result2;
+  }
+  const lenBytes = bigIntToBytes(BigInt(totalLen));
+  const result = new Uint8Array(1 + lenBytes.length + totalLen);
+  result[0] = 247 + lenBytes.length;
+  result.set(lenBytes, 1);
+  let offset = 1 + lenBytes.length;
+  for (const item of items) {
+    result.set(item, offset);
+    offset += item.length;
+  }
+  return result;
+}
+function bigIntToBytes(value) {
+  if (value === 0n) return new Uint8Array(0);
+  const hex = value.toString(16);
+  const padded = hex.length % 2 === 0 ? hex : `0${hex}`;
+  return hexToBytes2(padded);
+}
+function hexToBytes2(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < clean.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(clean.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function p1363ToDer(p1363) {
+  const r = p1363.subarray(0, 32);
+  const s = p1363.subarray(32, 64);
+  const rDer = integerToDer(r);
+  const sDer = integerToDer(s);
+  const seqLen = rDer.length + sDer.length;
+  const result = new Uint8Array(2 + seqLen);
+  result[0] = 48;
+  result[1] = seqLen;
+  result.set(rDer, 2);
+  result.set(sDer, 2 + rDer.length);
+  return result;
+}
+function integerToDer(bytes) {
+  let start = 0;
+  while (start < bytes.length - 1 && bytes[start] === 0) start++;
+  const stripped = bytes.subarray(start);
+  const needsPad = stripped[0] >= 128;
+  const len = stripped.length + (needsPad ? 1 : 0);
+  const result = new Uint8Array(2 + len);
+  result[0] = 2;
+  result[1] = len;
+  if (needsPad) {
+    result[2] = 0;
+    result.set(stripped, 3);
+  } else {
+    result.set(stripped, 2);
+  }
+  return result;
+}
+function derEncodeP256PrivateKey(rawKey) {
+  const header = new Uint8Array([
+    48,
+    65,
+    2,
+    1,
+    0,
+    48,
+    19,
+    6,
+    7,
+    42,
+    134,
+    72,
+    206,
+    61,
+    2,
+    1,
+    6,
+    8,
+    42,
+    134,
+    72,
+    206,
+    61,
+    3,
+    1,
+    7,
+    4,
+    39,
+    48,
+    37,
+    2,
+    1,
+    1,
+    4,
+    32
+  ]);
+  const result = new Uint8Array(header.length + rawKey.length);
+  result.set(header);
+  result.set(rawKey, header.length);
+  return result.buffer;
+}
+
+// src/adapters/private-key.ts
+var PrivateKeyAdapter = class _PrivateKeyAdapter {
+  name = "private-key";
+  capabilities = {
+    signMessage: true,
+    signTypedData: true,
+    managedGas: false,
+    managedNonce: false
+  };
+  onRequest;
+  onResponse;
+  config;
+  cachedAddress;
+  constructor(config) {
+    this.config = config;
+    this.cachedAddress = config.address;
+  }
+  static fromEnv() {
+    const privateKey = process.env.PRIVATE_KEY;
+    const rpcUrl = process.env.RPC_URL;
+    if (!privateKey) {
+      throw new Error("PRIVATE_KEY environment variable is required");
+    }
+    if (!rpcUrl) {
+      throw new Error("RPC_URL environment variable is required");
+    }
+    const clean = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
+    if (!/^[0-9a-fA-F]{64}$/.test(clean)) {
+      throw new Error(
+        "PRIVATE_KEY must be a 64-character hex string (with or without 0x prefix)"
+      );
+    }
+    return new _PrivateKeyAdapter({
+      privateKey,
+      rpcUrl,
+      address: process.env.WALLET_ADDRESS
+    });
+  }
+  getRpcUrl() {
+    return this.config.rpcUrl;
+  }
+  async getAddress() {
+    if (this.cachedAddress) return this.cachedAddress;
+    const clean = this.config.privateKey.startsWith("0x") ? this.config.privateKey.slice(2) : this.config.privateKey;
+    const pubKey = secp256k1.getPublicKey(clean, false);
+    const hash = keccak_2562(pubKey.subarray(1));
+    this.cachedAddress = `0x${nobleToHex(hash.subarray(12))}`;
+    return this.cachedAddress;
+  }
+  async sendTransaction(tx) {
+    this.onRequest?.("sendTransaction", tx);
+    const startTime = Date.now();
+    const from = await this.getAddress();
+    const { rpcUrl } = this.config;
+    let nonce;
+    let gasLimit;
+    let maxFeePerGas;
+    let maxPriorityFeePerGas;
+    if (tx.gas && tx.nonce !== void 0 && tx.maxFeePerGas) {
+      nonce = BigInt(tx.nonce);
+      gasLimit = BigInt(tx.gas);
+      maxFeePerGas = BigInt(tx.maxFeePerGas);
+      maxPriorityFeePerGas = tx.maxPriorityFeePerGas ? BigInt(tx.maxPriorityFeePerGas) : 1500000000n;
+    } else {
+      const txValue = tx.value === "0" ? "0x0" : `0x${BigInt(tx.value).toString(16)}`;
+      const [nonceResult, gasEstimateResult, feeDataResult] = await Promise.all(
+        [
+          this.rpcCall(rpcUrl, "eth_getTransactionCount", [from, "pending"]),
+          this.rpcCall(rpcUrl, "eth_estimateGas", [
+            { from, to: tx.to, data: tx.data || "0x", value: txValue }
+          ]),
+          this.rpcCall(rpcUrl, "eth_feeHistory", [1, "latest", [50]])
+        ]
+      );
+      nonce = BigInt(nonceResult);
+      const rawGas = BigInt(gasEstimateResult);
+      gasLimit = rawGas * 120n / 100n;
+      const feeHistory = feeDataResult;
+      const latestBaseFee = BigInt(
+        feeHistory.baseFeePerGas[1] ?? feeHistory.baseFeePerGas[0]
+      );
+      maxPriorityFeePerGas = feeHistory.reward?.[0]?.[0] ? BigInt(feeHistory.reward[0][0]) : 1500000000n;
+      maxFeePerGas = latestBaseFee * 2n + maxPriorityFeePerGas;
+    }
+    const unsignedHex = rlpEncodeEip1559Tx({
+      chainId: tx.chainId,
+      nonce,
+      maxPriorityFeePerGas,
+      maxFeePerGas,
+      gasLimit,
+      to: tx.to,
+      data: tx.data,
+      value: tx.value
+    });
+    const unsignedBytes = hexToBytes2(unsignedHex);
+    const txHash = keccak_2562(unsignedBytes);
+    const clean = this.config.privateKey.startsWith("0x") ? this.config.privateKey.slice(2) : this.config.privateKey;
+    const sig = secp256k1.sign(txHash, clean);
+    const signedHex = encodeSignedEip1559Tx(
+      {
+        chainId: tx.chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gasLimit,
+        to: tx.to,
+        data: tx.data,
+        value: tx.value
+      },
+      sig.recovery,
+      sig.r,
+      sig.s
+    );
+    const hash = await this.rpcCall(rpcUrl, "eth_sendRawTransaction", [
+      `0x${signedHex}`
+    ]);
+    const result = { hash };
+    this.onResponse?.("sendTransaction", result, Date.now() - startTime);
+    return result;
+  }
+  async signMessage(request) {
+    this.onRequest?.("signMessage", request);
+    const startTime = Date.now();
+    const hash = hashPersonalMessage(request.message);
+    const clean = this.config.privateKey.startsWith("0x") ? this.config.privateKey.slice(2) : this.config.privateKey;
+    const sig = secp256k1.sign(hash, clean);
+    const result = encodeEcdsaSignature(sig.r, sig.s, sig.recovery);
+    this.onResponse?.("signMessage", result, Date.now() - startTime);
+    return result;
+  }
+  async signTypedData(request) {
+    this.onRequest?.("signTypedData", request);
+    const startTime = Date.now();
+    const hash = hashTypedData(
+      request.domain,
+      request.primaryType,
+      request.message,
+      request.types
+    );
+    const clean = this.config.privateKey.startsWith("0x") ? this.config.privateKey.slice(2) : this.config.privateKey;
+    const sig = secp256k1.sign(hash, clean);
+    const result = encodeEcdsaSignature(sig.r, sig.s, sig.recovery);
+    this.onResponse?.("signTypedData", result, Date.now() - startTime);
+    return result;
+  }
+  async rpcCall(rpcUrl, method, params) {
+    const response = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`RPC ${method} failed (${response.status}): ${body}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`RPC ${method} error: ${data.error.message}`);
+    }
+    return data.result;
+  }
+};
+function bigIntToMinBytes(value) {
+  if (value === 0n) return new Uint8Array(0);
+  const hex = value.toString(16);
+  const padded = hex.length % 2 === 0 ? hex : `0${hex}`;
+  return hexToBytes2(padded);
+}
+function rlpEncodeBytes2(bytes) {
+  if (bytes.length === 1 && bytes[0] < 128) return bytes;
+  if (bytes.length === 0) return new Uint8Array([128]);
+  if (bytes.length <= 55) {
+    const result2 = new Uint8Array(1 + bytes.length);
+    result2[0] = 128 + bytes.length;
+    result2.set(bytes, 1);
+    return result2;
+  }
+  const lenBytes = bigIntToMinBytes(BigInt(bytes.length));
+  const result = new Uint8Array(1 + lenBytes.length + bytes.length);
+  result[0] = 183 + lenBytes.length;
+  result.set(lenBytes, 1);
+  result.set(bytes, 1 + lenBytes.length);
+  return result;
+}
+function rlpEncodeList2(items) {
+  let totalLen = 0;
+  for (const item of items) totalLen += item.length;
+  if (totalLen <= 55) {
+    const result2 = new Uint8Array(1 + totalLen);
+    result2[0] = 192 + totalLen;
+    let offset2 = 1;
+    for (const item of items) {
+      result2.set(item, offset2);
+      offset2 += item.length;
+    }
+    return result2;
+  }
+  const lenBytes = bigIntToMinBytes(BigInt(totalLen));
+  const result = new Uint8Array(1 + lenBytes.length + totalLen);
+  result[0] = 247 + lenBytes.length;
+  result.set(lenBytes, 1);
+  let offset = 1 + lenBytes.length;
+  for (const item of items) {
+    result.set(item, offset);
+    offset += item.length;
+  }
+  return result;
+}
+function encodeSignedEip1559Tx(tx, v, r, s) {
+  const fields = [
+    rlpEncodeBytes2(bigIntToMinBytes(BigInt(tx.chainId))),
+    rlpEncodeBytes2(bigIntToMinBytes(tx.nonce)),
+    rlpEncodeBytes2(bigIntToMinBytes(tx.maxPriorityFeePerGas)),
+    rlpEncodeBytes2(bigIntToMinBytes(tx.maxFeePerGas)),
+    rlpEncodeBytes2(bigIntToMinBytes(tx.gasLimit)),
+    rlpEncodeBytes2(hexToBytes2(tx.to)),
+    rlpEncodeBytes2(
+      tx.value === "0" ? new Uint8Array(0) : bigIntToMinBytes(BigInt(tx.value))
+    ),
+    rlpEncodeBytes2(tx.data ? hexToBytes2(tx.data) : new Uint8Array(0)),
+    rlpEncodeList2([]),
+    // empty access list
+    rlpEncodeBytes2(v === 0 ? new Uint8Array(0) : new Uint8Array([v])),
+    rlpEncodeBytes2(bigIntToMinBytes(r)),
+    rlpEncodeBytes2(bigIntToMinBytes(s))
+  ];
+  const rlpList = rlpEncodeList2(fields);
+  const signed = new Uint8Array(1 + rlpList.length);
+  signed[0] = 2;
+  signed.set(rlpList, 1);
+  return bytesToHex(signed);
+}
+function encodeEcdsaSignature(r, s, v) {
+  const rHex = r.toString(16).padStart(64, "0");
+  const sHex = s.toString(16).padStart(64, "0");
+  const vHex = (v + 27).toString(16).padStart(2, "0");
+  return `0x${rHex}${sHex}${vHex}`;
+}
+
+// src/adapters/privy.ts
+var PRIVY_API_BASE = "https://api.privy.io";
+var PrivyAdapter = class _PrivyAdapter {
+  name = "privy";
+  capabilities = {
+    signMessage: true,
+    signTypedData: true,
+    managedGas: true,
+    managedNonce: true
+  };
+  onRequest;
+  onResponse;
+  config;
+  cachedAddress;
+  constructor(config) {
+    this.config = config;
+  }
+  static fromEnv() {
+    const appId = process.env.PRIVY_APP_ID;
+    const appSecret = process.env.PRIVY_APP_SECRET;
+    const walletId = process.env.PRIVY_WALLET_ID;
+    if (!appId) {
+      throw new Error("PRIVY_APP_ID environment variable is required");
+    }
+    if (!appSecret) {
+      throw new Error("PRIVY_APP_SECRET environment variable is required");
+    }
+    if (!walletId) {
+      throw new Error("PRIVY_WALLET_ID environment variable is required");
+    }
+    return new _PrivyAdapter({
+      appId,
+      appSecret,
+      walletId,
+      baseUrl: process.env.PRIVY_API_BASE_URL
+    });
+  }
+  get baseUrl() {
+    return this.config.baseUrl ?? PRIVY_API_BASE;
+  }
+  get authHeaders() {
+    const credentials = Buffer.from(
+      `${this.config.appId}:${this.config.appSecret}`
+    ).toString("base64");
+    return {
+      Authorization: `Basic ${credentials}`,
+      "privy-app-id": this.config.appId,
+      "Content-Type": "application/json"
+    };
+  }
+  async getAddress() {
+    if (this.cachedAddress) return this.cachedAddress;
+    const response = await fetch(
+      `${this.baseUrl}/v1/wallets/${this.config.walletId}`,
+      { headers: this.authHeaders }
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Privy getAddress failed (${response.status}): ${body}`);
+    }
+    const data = await response.json();
+    this.cachedAddress = data.address;
+    return data.address;
+  }
+  async sendTransaction(tx) {
+    this.onRequest?.("sendTransaction", tx);
+    const startTime = Date.now();
+    const caip2 = `eip155:${tx.chainId}`;
+    const response = await fetch(
+      `${this.baseUrl}/v1/wallets/${this.config.walletId}/rpc`,
+      {
+        method: "POST",
+        headers: this.authHeaders,
+        body: JSON.stringify({
+          method: "eth_sendTransaction",
+          caip2,
+          params: {
+            transaction: {
+              to: tx.to,
+              data: tx.data,
+              value: tx.value
+            }
+          }
+        })
+      }
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Privy sendTransaction failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    const result = { hash: data.data.hash };
+    this.onResponse?.("sendTransaction", result, Date.now() - startTime);
+    return result;
+  }
+  async signMessage(request) {
+    this.onRequest?.("signMessage", request);
+    const startTime = Date.now();
+    const message = typeof request.message === "string" ? request.message : `0x${Buffer.from(request.message).toString("hex")}`;
+    const response = await fetch(
+      `${this.baseUrl}/v1/wallets/${this.config.walletId}/rpc`,
+      {
+        method: "POST",
+        headers: this.authHeaders,
+        body: JSON.stringify({
+          method: "personal_sign",
+          params: { message }
+        })
+      }
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Privy signMessage failed (${response.status}): ${body}`);
+    }
+    const data = await response.json();
+    this.onResponse?.(
+      "signMessage",
+      data.data.signature,
+      Date.now() - startTime
+    );
+    return data.data.signature;
+  }
+  async signTypedData(request) {
+    this.onRequest?.("signTypedData", request);
+    const startTime = Date.now();
+    const response = await fetch(
+      `${this.baseUrl}/v1/wallets/${this.config.walletId}/rpc`,
+      {
+        method: "POST",
+        headers: this.authHeaders,
+        body: JSON.stringify({
+          method: "eth_signTypedData_v4",
+          params: {
+            typedData: JSON.stringify({
+              domain: request.domain,
+              types: request.types,
+              primaryType: request.primaryType,
+              message: request.message
+            })
+          }
+        })
+      }
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `Privy signTypedData failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    this.onResponse?.(
+      "signTypedData",
+      data.data.signature,
+      Date.now() - startTime
+    );
+    return data.data.signature;
+  }
+};
+
+// src/factory.ts
+function createWalletFromEnv() {
+  if (process.env.PRIVY_APP_ID && process.env.PRIVY_WALLET_ID) {
+    return PrivyAdapter.fromEnv();
+  }
+  if (process.env.FIREBLOCKS_API_KEY && process.env.FIREBLOCKS_VAULT_ID) {
+    return FireblocksAdapter.fromEnv();
+  }
+  if (process.env.TURNKEY_API_PUBLIC_KEY && process.env.TURNKEY_WALLET_ADDRESS) {
+    return TurnkeyAdapter.fromEnv();
+  }
+  if (process.env.PRIVATE_KEY) {
+    return PrivateKeyAdapter.fromEnv();
+  }
+  throw new Error(
+    "No wallet provider configured. Set environment variables for one of:\n  \u2022 Privy: PRIVY_APP_ID, PRIVY_APP_SECRET, PRIVY_WALLET_ID\n  \u2022 Fireblocks: FIREBLOCKS_API_KEY, FIREBLOCKS_API_SECRET, FIREBLOCKS_VAULT_ID\n  \u2022 Turnkey: TURNKEY_API_PUBLIC_KEY, TURNKEY_API_PRIVATE_KEY, TURNKEY_ORGANIZATION_ID, TURNKEY_WALLET_ADDRESS, TURNKEY_RPC_URL\n  \u2022 PrivateKey: PRIVATE_KEY, RPC_URL"
+  );
+}
+function createWalletForProvider(provider) {
+  switch (provider) {
+    case "privy":
+      return PrivyAdapter.fromEnv();
+    case "fireblocks":
+      return FireblocksAdapter.fromEnv();
+    case "turnkey":
+      return TurnkeyAdapter.fromEnv();
+    case "private-key":
+      return PrivateKeyAdapter.fromEnv();
+    default:
+      throw new Error(`Unknown wallet provider: ${provider}`);
+  }
+}
+function detectProvider() {
+  if (process.env.PRIVY_APP_ID && process.env.PRIVY_WALLET_ID) return "privy";
+  if (process.env.FIREBLOCKS_API_KEY && process.env.FIREBLOCKS_VAULT_ID)
+    return "fireblocks";
+  if (process.env.TURNKEY_API_PUBLIC_KEY && process.env.TURNKEY_WALLET_ADDRESS)
+    return "turnkey";
+  if (process.env.PRIVATE_KEY) return "private-key";
+  return null;
+}
+
+// src/types/index.ts
+var WALLET_PROVIDERS = [
+  "privy",
+  "turnkey",
+  "fireblocks",
+  "private-key"
+];
+export {
+  CHAIN_TO_FIREBLOCKS_ASSET,
+  FireblocksAdapter,
+  PrivateKeyAdapter,
+  PrivyAdapter,
+  TurnkeyAdapter,
+  WALLET_PROVIDERS,
+  createWalletForProvider,
+  createWalletFromEnv,
+  detectProvider
+};
+//# sourceMappingURL=index.js.map