@veridex/sdk 1.1.1 → 1.1.3

package/dist/chains/evm/index.mjs

@@ -3,7 +3,7 @@ import {
 } from "../../chunk-V636MIV3.mjs";
 import {
   EVMClient
-} from "../../chunk-YBN2VC6E.mjs";
+} from "../../chunk-E5HHE7IW.mjs";
 import "../../chunk-TPEP6XUA.mjs";
 import "../../chunk-RD6ZYUVG.mjs";
 export {

package/dist/chains/stacks/index.d.mts

@@ -1,4 +1,4 @@
-import { a as SessionKey } from '../../types-DWx-5jmz.mjs';
+import { a as SessionKey } from '../../types-C564CfsE.mjs';
 import { C as ChainClient, a as ChainConfig, T as TransferParams, E as ExecuteParams, B as BridgeParams, W as WebAuthnSignature, D as DispatchResult, V as VaultCreationResult, x as RegisterSessionParams, y as RevokeSessionParams, S as SessionValidationResult } from '../../types-DP2CQT8p.mjs';
 
 /**

package/dist/chains/starknet/index.d.mts

@@ -1,4 +1,4 @@
-import { a as SessionKey } from '../../types-DWx-5jmz.mjs';
+import { a as SessionKey } from '../../types-C564CfsE.mjs';
 import { C as ChainClient, a as ChainConfig, T as TransferParams, E as ExecuteParams, B as BridgeParams, W as WebAuthnSignature, D as DispatchResult, V as VaultCreationResult, x as RegisterSessionParams, y as RevokeSessionParams, S as SessionValidationResult } from '../../types-DP2CQT8p.mjs';
 import { RpcProvider } from 'starknet';
 

package/dist/chains/stellar/index.d.mts

@@ -0,0 +1,312 @@
+import { PasskeyManager, PasskeyCredential } from '../../passkey.mjs';
+
+/**
+ * Veridex Protocol SDK — Stellar chain types
+ *
+ * Local mirror of the subset of the Stellar-Wallets-Kit `ModuleInterface`
+ * contract we implement. We mirror it (rather than importing from
+ * `@creit.tech/stellar-wallets-kit`) so `@veridex/sdk` does not gain a hard
+ * peer dependency on the kit. Consumers who already depend on the kit can
+ * cast our module to the upstream type — the shapes are structurally
+ * identical.
+ *
+ * Upstream reference: `@creit.tech/stellar-wallets-kit` →
+ *   src/types/mod.ts → `ModuleInterface`
+ */
+declare enum StellarNetworks {
+    PUBLIC = "Public Global Stellar Network ; September 2015",
+    TESTNET = "Test SDF Network ; September 2015",
+    FUTURENET = "Test SDF Future Network ; October 2022",
+    SANDBOX = "Local Sandbox Stellar Network ; September 2022",
+    STANDALONE = "Standalone Network ; February 2017"
+}
+declare enum StellarModuleType {
+    HW_WALLET = "HW_WALLET",
+    HOT_WALLET = "HOT_WALLET",
+    BRIDGE_WALLET = "BRIDGE_WALLET",
+    AIR_GAPED_WALLET = "AIR_GAPED_WALLET"
+}
+interface StellarKitError {
+    code: number;
+    message: string;
+    ext?: string;
+}
+/**
+ * Stellar-Wallets-Kit `ModuleInterface` mirror.
+ * Only the methods we implement are documented; signature-compatible with
+ * the upstream contract.
+ */
+interface StellarWalletModuleInterface {
+    moduleType: StellarModuleType;
+    productId: string;
+    productName: string;
+    productUrl: string;
+    productIcon: string;
+    isAvailable(): Promise<boolean>;
+    isPlatformWrapper?(): Promise<boolean>;
+    getAddress(params?: {
+        path?: string;
+        skipRequestAccess?: boolean;
+    }): Promise<{
+        address: string;
+    }>;
+    signTransaction(xdr: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<{
+        signedTxXdr: string;
+        signerAddress?: string;
+    }>;
+    signAuthEntry(authEntry: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<{
+        signedAuthEntry: string;
+        signerAddress?: string;
+    }>;
+    signMessage(message: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<{
+        signedMessage: string;
+        signerAddress?: string;
+    }>;
+}
+/**
+ * Veridex-specific configuration for the Stellar passkey signer.
+ */
+interface VeridexStellarConfig {
+    /** Stellar network passphrase. Defaults to TESTNET. */
+    network?: StellarNetworks;
+    /**
+     * Soroban RPC URL (used to resolve the smart-account address or submit
+     * transactions when `signAndSubmitTransaction` is invoked).
+     */
+    rpcUrl?: string;
+    /**
+     * Optional pre-deployed smart-account contract id (C-address). If
+     * provided, `getAddress()` returns this directly. Otherwise the address
+     * is derived deterministically from the passkey `keyHash`.
+     */
+    smartAccountContractId?: string;
+    /**
+     * Override the deterministic smart-account factory contract. Used for
+     * address derivation when `smartAccountContractId` is not set.
+     */
+    smartAccountFactory?: string;
+}
+/**
+ * A signed WebAuthn assertion ready to be embedded in a Soroban auth entry.
+ *
+ * The shape matches what a Soroban smart-account's `__check_auth` entrypoint
+ * needs to verify a secp256r1 passkey signature:
+ *   - `keyHash` identifies which registered passkey signed
+ *   - `authenticatorData` + `clientDataJSON` are the WebAuthn assertion
+ *   - `r`, `s` are the secp256r1 signature components
+ */
+interface PasskeyAuthAssertion {
+    keyHash: string;
+    authenticatorData: string;
+    clientDataJSON: string;
+    challengeIndex: number;
+    typeIndex: number;
+    signatureR: string;
+    signatureS: string;
+}
+
+/**
+ * Veridex Protocol SDK — Stellar Passkey Signer
+ *
+ * Bridges Veridex's WebAuthn `PasskeyManager` to the SEP-43 signing surface
+ * expected by Soroban smart accounts (and the Stellar-Wallets-Kit
+ * `ModuleInterface`).
+ *
+ * Design:
+ *   - The signer treats every SEP-43 signing call (transaction / auth entry
+ *     / message) as a request to produce a WebAuthn assertion over the
+ *     SHA-256 of a canonical preimage.
+ *   - For a transaction we hash `network_id || tagged_tx_envelope` per the
+ *     XDR-hash spec; for an auth entry we hash the
+ *     `HashIdPreimageSorobanAuthorization`; for a message we hash the bytes
+ *     directly.
+ *   - The returned `signedTxXdr` / `signedAuthEntry` strings are
+ *     base64-encoded JSON containers carrying the assertion. The downstream
+ *     Soroban smart-account contract (`__check_auth`) is responsible for
+ *     parsing the container, verifying secp256r1, and authorizing.
+ *
+ *   This separation lets `@veridex/sdk` ship without a hard dependency on
+ *   `@stellar/stellar-sdk`. Consumers who want full XDR-aware signing can
+ *   subclass and override `hashTransactionXdr` / `hashAuthEntry`.
+ */
+
+interface StellarPasskeySignerOptions {
+    passkey: PasskeyManager;
+    credential?: PasskeyCredential;
+    config?: VeridexStellarConfig;
+}
+declare class StellarPasskeySigner {
+    private readonly passkey;
+    private credential?;
+    private readonly network;
+    private readonly smartAccountContractId?;
+    constructor(opts: StellarPasskeySignerOptions);
+    /**
+     * Returns the Soroban smart-account address (C-address-derivable hex)
+     * associated with the active passkey. If a fixed contract id was
+     * configured we return it verbatim; otherwise we derive deterministically.
+     */
+    getAddress(skipRequestAccess?: boolean): Promise<{
+        address: string;
+    }>;
+    /**
+     * Produce a SEP-43 `signedTxXdr` for the given transaction envelope XDR.
+     *
+     * Because we do not bundle `@stellar/stellar-sdk` we hash the XDR's
+     * binary form prefixed with the network passphrase. Consumers that need
+     * canonical Stellar transaction hashes should preprocess `xdr` to the
+     * spec-compliant preimage before calling, or override this method.
+     */
+    signTransaction(xdr: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+    }): Promise<{
+        signedTxXdr: string;
+        signerAddress: string;
+    }>;
+    /**
+     * Sign a Soroban `HashIdPreimageSorobanAuthorization` XDR. The auth
+     * entry payload is hashed and wrapped identically to a transaction.
+     */
+    signAuthEntry(authEntry: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+    }): Promise<{
+        signedAuthEntry: string;
+        signerAddress: string;
+    }>;
+    /**
+     * Sign an arbitrary message per SEP-43 `signMessage`.
+     */
+    signMessage(message: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+    }): Promise<{
+        signedMessage: string;
+        signerAddress: string;
+    }>;
+    protected hashTransactionXdr(xdr: string, networkPassphrase: string): Uint8Array;
+    protected hashAuthEntry(authEntry: string, networkPassphrase: string): Uint8Array;
+    private signChallenge;
+    private ensureCredential;
+    private encodeAssertionContainer;
+    private decodeBase64;
+}
+
+/**
+ * Veridex Protocol SDK — Stellar-Wallets-Kit ModuleInterface implementation
+ *
+ * Drop-in module for `@creit.tech/stellar-wallets-kit` that exposes
+ * Veridex's passkey-backed Soroban smart account as a wallet option.
+ *
+ * Usage (downstream app):
+ * ```ts
+ * import { StellarWalletsKit, allowAllModules } from '@creit.tech/stellar-wallets-kit';
+ * import { PasskeyManager } from '@veridex/sdk/passkey';
+ * import { VeridexStellarWalletModule } from '@veridex/sdk/chains/stellar';
+ *
+ * const passkey = new PasskeyManager({ rpName: 'My Dapp' });
+ * const veridexModule = new VeridexStellarWalletModule({ passkey });
+ *
+ * const kit = new StellarWalletsKit({
+ *   network: WalletNetwork.TESTNET,
+ *   selectedWalletId: VERIDEX_PASSKEY_ID,
+ *   modules: [...allowAllModules(), veridexModule],
+ * });
+ * ```
+ */
+
+declare const VERIDEX_PASSKEY_ID = "veridex-passkey";
+interface VeridexStellarWalletModuleOptions {
+    passkey: PasskeyManager;
+    credential?: PasskeyCredential;
+    config?: VeridexStellarConfig;
+    productName?: string;
+    productUrl?: string;
+    productIcon?: string;
+}
+declare class VeridexStellarWalletModule implements StellarWalletModuleInterface {
+    readonly moduleType: StellarModuleType;
+    readonly productId: string;
+    readonly productName: string;
+    readonly productUrl: string;
+    readonly productIcon: string;
+    private readonly signer;
+    constructor(opts: VeridexStellarWalletModuleOptions);
+    isAvailable(): Promise<boolean>;
+    isPlatformWrapper(): Promise<boolean>;
+    getAddress(params?: {
+        path?: string;
+        skipRequestAccess?: boolean;
+    }): Promise<{
+        address: string;
+    }>;
+    signTransaction(xdr: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<{
+        signedTxXdr: string;
+        signerAddress?: string;
+    }>;
+    signAuthEntry(authEntry: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<{
+        signedAuthEntry: string;
+        signerAddress?: string;
+    }>;
+    signMessage(message: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<{
+        signedMessage: string;
+        signerAddress?: string;
+    }>;
+}
+
+/**
+ * Veridex Protocol SDK — Soroban smart-account address derivation
+ *
+ * The Veridex Stellar adapter binds a WebAuthn passkey to a Soroban smart
+ * account whose `__check_auth` entry verifies secp256r1 signatures against
+ * the passkey's `keyHash`.
+ *
+ * For the credibility-artifact stage we expose deterministic address
+ * derivation only — actual deployment is handled by a separate Soroban
+ * factory contract (see `contracts/stellar/` once added). This keeps the
+ * SDK chain-agnostic and avoids pulling in the heavy `@stellar/stellar-sdk`
+ * runtime.
+ */
+/**
+ * Deterministically derive a Soroban contract id (C-address) from a passkey
+ * `keyHash`. This mirrors the SEP-0011 Stellar contract-id derivation
+ * scheme: contract_id = sha256(networkPassphrase || keyHash || salt).
+ *
+ * NOTE: This returns a stable 32-byte identifier encoded as hex. To produce
+ * a canonical `C...` strkey representation the consumer must encode it with
+ * `StrKey.encodeContract` from `@stellar/stellar-sdk`. We deliberately keep
+ * the encoding out of `@veridex/sdk` to avoid a hard dependency.
+ *
+ * @param keyHash - The Veridex passkey keyHash (hex, with or without 0x).
+ * @param networkPassphrase - Stellar network passphrase (e.g. testnet).
+ * @param salt - Optional 32-byte salt (hex). Defaults to all-zeros.
+ * @returns The 32-byte contract id encoded as a 0x-prefixed hex string.
+ */
+declare function deriveSmartAccountId(keyHash: string, networkPassphrase: string, salt?: string): string;
+
+export { type PasskeyAuthAssertion, type StellarKitError, StellarModuleType, StellarNetworks, StellarPasskeySigner, type StellarPasskeySignerOptions, type StellarWalletModuleInterface, VERIDEX_PASSKEY_ID, type VeridexStellarConfig, VeridexStellarWalletModule, type VeridexStellarWalletModuleOptions, deriveSmartAccountId };

package/dist/chains/stellar/index.js

@@ -0,0 +1,300 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/chains/stellar/index.ts
+var stellar_exports = {};
+__export(stellar_exports, {
+  StellarModuleType: () => StellarModuleType,
+  StellarNetworks: () => StellarNetworks,
+  StellarPasskeySigner: () => StellarPasskeySigner,
+  VERIDEX_PASSKEY_ID: () => VERIDEX_PASSKEY_ID,
+  VeridexStellarWalletModule: () => VeridexStellarWalletModule,
+  deriveSmartAccountId: () => deriveSmartAccountId
+});
+module.exports = __toCommonJS(stellar_exports);
+
+// src/chains/stellar/StellarPasskeySigner.ts
+var import_sha2562 = require("@noble/hashes/sha256");
+
+// src/utils.ts
+var import_ethers = require("ethers");
+function base64URLDecode(str) {
+  const base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/chains/stellar/types.ts
+var StellarNetworks = /* @__PURE__ */ ((StellarNetworks2) => {
+  StellarNetworks2["PUBLIC"] = "Public Global Stellar Network ; September 2015";
+  StellarNetworks2["TESTNET"] = "Test SDF Network ; September 2015";
+  StellarNetworks2["FUTURENET"] = "Test SDF Future Network ; October 2022";
+  StellarNetworks2["SANDBOX"] = "Local Sandbox Stellar Network ; September 2022";
+  StellarNetworks2["STANDALONE"] = "Standalone Network ; February 2017";
+  return StellarNetworks2;
+})(StellarNetworks || {});
+var StellarModuleType = /* @__PURE__ */ ((StellarModuleType2) => {
+  StellarModuleType2["HW_WALLET"] = "HW_WALLET";
+  StellarModuleType2["HOT_WALLET"] = "HOT_WALLET";
+  StellarModuleType2["BRIDGE_WALLET"] = "BRIDGE_WALLET";
+  StellarModuleType2["AIR_GAPED_WALLET"] = "AIR_GAPED_WALLET";
+  return StellarModuleType2;
+})(StellarModuleType || {});
+
+// src/chains/stellar/SmartAccount.ts
+var import_sha256 = require("@noble/hashes/sha256");
+function deriveSmartAccountId(keyHash, networkPassphrase, salt) {
+  const cleanHash = keyHash.startsWith("0x") ? keyHash.slice(2) : keyHash;
+  if (cleanHash.length !== 64) {
+    throw new Error(
+      `deriveSmartAccountId: keyHash must be 32 bytes (64 hex chars), got ${cleanHash.length}`
+    );
+  }
+  const cleanSalt = salt ? salt.startsWith("0x") ? salt.slice(2) : salt : "0".repeat(64);
+  if (cleanSalt.length !== 64) {
+    throw new Error(
+      `deriveSmartAccountId: salt must be 32 bytes (64 hex chars), got ${cleanSalt.length}`
+    );
+  }
+  const encoder = new TextEncoder();
+  const passphraseBytes = encoder.encode(networkPassphrase);
+  const keyHashBytes = hexToBytes(cleanHash);
+  const saltBytes = hexToBytes(cleanSalt);
+  const buffer = new Uint8Array(
+    passphraseBytes.length + keyHashBytes.length + saltBytes.length
+  );
+  buffer.set(passphraseBytes, 0);
+  buffer.set(keyHashBytes, passphraseBytes.length);
+  buffer.set(saltBytes, passphraseBytes.length + keyHashBytes.length);
+  const digest = (0, import_sha256.sha256)(buffer);
+  return "0x" + bytesToHex(digest);
+}
+function hexToBytes(hex) {
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bytesToHex(bytes) {
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+// src/chains/stellar/StellarPasskeySigner.ts
+var StellarPasskeySigner = class {
+  passkey;
+  credential;
+  network;
+  smartAccountContractId;
+  constructor(opts) {
+    this.passkey = opts.passkey;
+    this.credential = opts.credential;
+    this.network = opts.config?.network ?? "Test SDF Network ; September 2015" /* TESTNET */;
+    this.smartAccountContractId = opts.config?.smartAccountContractId;
+  }
+  /**
+   * Returns the Soroban smart-account address (C-address-derivable hex)
+   * associated with the active passkey. If a fixed contract id was
+   * configured we return it verbatim; otherwise we derive deterministically.
+   */
+  async getAddress(skipRequestAccess = false) {
+    if (this.smartAccountContractId) {
+      return { address: this.smartAccountContractId };
+    }
+    const cred = await this.ensureCredential(skipRequestAccess);
+    const id = deriveSmartAccountId(cred.keyHash, this.network);
+    return { address: id };
+  }
+  /**
+   * Produce a SEP-43 `signedTxXdr` for the given transaction envelope XDR.
+   *
+   * Because we do not bundle `@stellar/stellar-sdk` we hash the XDR's
+   * binary form prefixed with the network passphrase. Consumers that need
+   * canonical Stellar transaction hashes should preprocess `xdr` to the
+   * spec-compliant preimage before calling, or override this method.
+   */
+  async signTransaction(xdr, opts) {
+    const cred = await this.ensureCredential(true);
+    const passphrase = opts?.networkPassphrase ?? this.network;
+    const challenge = this.hashTransactionXdr(xdr, passphrase);
+    const assertion = await this.signChallenge(challenge, cred);
+    const container = this.encodeAssertionContainer("tx", xdr, assertion);
+    const { address } = await this.getAddress(true);
+    return { signedTxXdr: container, signerAddress: opts?.address ?? address };
+  }
+  /**
+   * Sign a Soroban `HashIdPreimageSorobanAuthorization` XDR. The auth
+   * entry payload is hashed and wrapped identically to a transaction.
+   */
+  async signAuthEntry(authEntry, opts) {
+    const cred = await this.ensureCredential(true);
+    const passphrase = opts?.networkPassphrase ?? this.network;
+    const challenge = this.hashAuthEntry(authEntry, passphrase);
+    const assertion = await this.signChallenge(challenge, cred);
+    const container = this.encodeAssertionContainer("auth", authEntry, assertion);
+    const { address } = await this.getAddress(true);
+    return { signedAuthEntry: container, signerAddress: opts?.address ?? address };
+  }
+  /**
+   * Sign an arbitrary message per SEP-43 `signMessage`.
+   */
+  async signMessage(message, opts) {
+    const cred = await this.ensureCredential(true);
+    const challenge = (0, import_sha2562.sha256)(new TextEncoder().encode(message));
+    const assertion = await this.signChallenge(challenge, cred);
+    const container = this.encodeAssertionContainer("msg", message, assertion);
+    const { address } = await this.getAddress(true);
+    return { signedMessage: container, signerAddress: opts?.address ?? address };
+  }
+  // ------------------------------------------------------------------
+  // Internals
+  // ------------------------------------------------------------------
+  hashTransactionXdr(xdr, networkPassphrase) {
+    const passphraseHash = (0, import_sha2562.sha256)(new TextEncoder().encode(networkPassphrase));
+    const xdrBytes = this.decodeBase64(xdr);
+    const buf = new Uint8Array(passphraseHash.length + xdrBytes.length);
+    buf.set(passphraseHash, 0);
+    buf.set(xdrBytes, passphraseHash.length);
+    return (0, import_sha2562.sha256)(buf);
+  }
+  hashAuthEntry(authEntry, networkPassphrase) {
+    return this.hashTransactionXdr(authEntry, networkPassphrase);
+  }
+  async signChallenge(challenge, credential) {
+    const sig = await this.passkey.sign(challenge);
+    return {
+      keyHash: credential.keyHash,
+      authenticatorData: sig.authenticatorData,
+      clientDataJSON: sig.clientDataJSON,
+      challengeIndex: sig.challengeIndex,
+      typeIndex: sig.typeIndex,
+      signatureR: "0x" + sig.r.toString(16).padStart(64, "0"),
+      signatureS: "0x" + sig.s.toString(16).padStart(64, "0")
+    };
+  }
+  async ensureCredential(skipRequestAccess) {
+    if (this.credential) return this.credential;
+    if (skipRequestAccess) {
+      throw new Error(
+        "StellarPasskeySigner: no credential cached. Call passkey.authenticate() first or pass `credential` to the constructor."
+      );
+    }
+    const { credential } = await this.passkey.authenticate();
+    this.credential = credential;
+    return credential;
+  }
+  encodeAssertionContainer(kind, payload, assertion) {
+    const container = {
+      v: 1,
+      kind,
+      payload,
+      assertion
+    };
+    const json = JSON.stringify(container);
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(json, "utf8").toString("base64");
+    }
+    return btoa(unescape(encodeURIComponent(json)));
+  }
+  decodeBase64(input) {
+    try {
+      if (typeof Buffer !== "undefined") {
+        return new Uint8Array(Buffer.from(input, "base64"));
+      }
+      const binary = atob(input);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+      return bytes;
+    } catch {
+      return base64URLDecode(input);
+    }
+  }
+};
+
+// src/chains/stellar/VeridexStellarWalletModule.ts
+var import_browser = require("@simplewebauthn/browser");
+var VERIDEX_PASSKEY_ID = "veridex-passkey";
+var VeridexStellarWalletModule = class {
+  moduleType = "HOT_WALLET" /* HOT_WALLET */;
+  productId = VERIDEX_PASSKEY_ID;
+  productName;
+  productUrl;
+  productIcon;
+  signer;
+  constructor(opts) {
+    this.signer = new StellarPasskeySigner({
+      passkey: opts.passkey,
+      credential: opts.credential,
+      config: opts.config
+    });
+    this.productName = opts.productName ?? "Veridex Passkey";
+    this.productUrl = opts.productUrl ?? "https://veridex.network";
+    this.productIcon = opts.productIcon ?? "https://veridex.network/icons/passkey-256.png";
+  }
+  async isAvailable() {
+    try {
+      return (0, import_browser.browserSupportsWebAuthn)();
+    } catch {
+      return false;
+    }
+  }
+  async isPlatformWrapper() {
+    return false;
+  }
+  async getAddress(params) {
+    return this.signer.getAddress(params?.skipRequestAccess);
+  }
+  async signTransaction(xdr, opts) {
+    return this.signer.signTransaction(xdr, {
+      networkPassphrase: opts?.networkPassphrase,
+      address: opts?.address
+    });
+  }
+  async signAuthEntry(authEntry, opts) {
+    return this.signer.signAuthEntry(authEntry, {
+      networkPassphrase: opts?.networkPassphrase,
+      address: opts?.address
+    });
+  }
+  async signMessage(message, opts) {
+    return this.signer.signMessage(message, {
+      networkPassphrase: opts?.networkPassphrase,
+      address: opts?.address
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StellarModuleType,
+  StellarNetworks,
+  StellarPasskeySigner,
+  VERIDEX_PASSKEY_ID,
+  VeridexStellarWalletModule,
+  deriveSmartAccountId
+});
+//# sourceMappingURL=index.js.map