@human.tech/waap-sdk 2.0.0 → 2.1.0-staging-fb27bb

package/dist/index-CdKntlzX.d.mts

@@ -0,0 +1,775 @@
+import { C as RequestPermissionTokenResult, M as WaaPSessionProtection, S as RequestPermissionTokenParams, a as PermissionTokenQuery, b as CustomConfig, c as SilkEthereumProviderInterface, d as WaaPAccountStatus, h as WaaPWalletTargetOptions, i as PermissionTokenClearResult, n as InitSilkOptions, o as PermissionTokenStatus, p as WaaPSessionExtension, r as LoginResponse, v as AuthenticationMethod, x as ProjectConfig } from "./types-DexmJNke.mjs";
+//#region src/lib/sui/types.d.ts
+/**
+ * Sui chain identifiers.
+ */
+type SuiChain = 'sui:mainnet' | 'sui:testnet' | 'sui:devnet' | 'sui:localnet';
+/**
+ * Sui account representation following Wallet Standard.
+ */
+interface SuiAccount {
+  /** Sui address (32 bytes, 0x-prefixed hex string) */
+  readonly address: string;
+  /** Compressed public key bytes (33 bytes for Secp256k1) */
+  readonly publicKey: Uint8Array;
+  /** Supported chains for this account */
+  readonly chains: readonly SuiChain[];
+  /** Supported features for this account */
+  readonly features: readonly string[];
+  /** Optional display label */
+  readonly label?: string;
+}
+/**
+ * Input for sui:signPersonalMessage feature.
+ */
+interface SuiSignPersonalMessageInput {
+  /** Message bytes to sign */
+  message: Uint8Array;
+  /** Account to sign with */
+  account: SuiAccount;
+  /** Optional chain identifier */
+  chain?: SuiChain;
+  /** Cancel the pending iframe request without changing wallet-standard payloads. */
+  signal?: AbortSignal;
+  /** SDK-side timeout for a non-interactive iframe request, in milliseconds. */
+  timeoutMs?: number;
+}
+/**
+ * Output from sui:signPersonalMessage feature.
+ */
+interface SuiSignPersonalMessageOutput {
+  /** Base64-encoded message bytes */
+  bytes: string;
+  /** Base64-encoded signature (98 bytes for Secp256k1) */
+  signature: string;
+}
+/** Bytes, base64 bytes, or a transaction-like object the runtime can build. */
+type SuiTransactionInput = Uint8Array | readonly number[] | string | {
+  build?: (...args: any[]) => Promise<Uint8Array> | Uint8Array;
+  serialize?: (...args: any[]) => Promise<Uint8Array | string> | Uint8Array | string;
+  toJSON?: () => Promise<unknown> | unknown;
+  /**
+   * Present on some Mysten Transaction versions. WaaP only consumes it
+   * when it returns bytes; a transaction with build() remains valid when
+   * this method returns the SDK's structured transaction data.
+   */
+  getData?: () => unknown;
+};
+/**
+ * Input for sui:signTransaction feature.
+ */
+interface SuiSignTransactionInput {
+  /** BCS bytes, base64 BCS, or a transaction-like object. */
+  transaction: SuiTransactionInput;
+  /** Account to sign with */
+  account: SuiAccount;
+  /** Optional chain identifier */
+  chain?: SuiChain;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+/**
+ * Output from sui:signTransaction feature.
+ */
+interface SuiSignTransactionOutput {
+  /** Base64-encoded transaction bytes */
+  bytes: string;
+  /** Base64-encoded signature */
+  signature: string;
+}
+/**
+ * Input for sui:signAndExecuteTransaction feature.
+ */
+interface SuiSignAndExecuteTransactionInput {
+  /** BCS bytes, base64 BCS, or a transaction-like object. */
+  transaction: SuiTransactionInput;
+  /** Account to sign with */
+  account: SuiAccount;
+  /** Optional chain identifier */
+  chain?: SuiChain;
+  /** Options for execution */
+  options?: unknown;
+  /** Request type */
+  requestType?: 'WaitForEffectsCert' | 'WaitForLocalExecution';
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+/**
+ * Output from sui:signAndExecuteTransaction feature.
+ */
+interface SuiSignAndExecuteTransactionOutput {
+  digest: string;
+  effects?: unknown;
+  errors?: unknown[];
+  [key: string]: unknown;
+}
+/**
+ * Connect input options.
+ */
+interface SuiConnectInput {
+  /** If true, attempt silent connection without UI prompt */
+  silent?: boolean;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+/**
+ * Connect output with accounts.
+ */
+interface SuiConnectOutput {
+  /** Connected accounts */
+  accounts: readonly SuiAccount[];
+}
+/**
+ * Input for legacy sui:signTransactionBlock feature.
+ */
+interface SuiSignTransactionBlockInput {
+  /** BCS-serialized transaction block bytes */
+  transactionBlock: Uint8Array;
+  /** Account to sign with */
+  account: SuiAccount;
+  /** Optional chain identifier */
+  chain?: SuiChain;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+/**
+ * Output for legacy sui:signTransactionBlock feature.
+ */
+interface SuiSignTransactionBlockOutput extends SuiSignTransactionOutput {}
+/**
+ * Input for legacy sui:signAndExecuteTransactionBlock feature.
+ */
+interface SuiSignAndExecuteTransactionBlockInput {
+  /** BCS-serialized transaction block bytes */
+  transactionBlock: Uint8Array;
+  /** Account to sign with */
+  account: SuiAccount;
+  /** Optional chain identifier */
+  chain?: SuiChain;
+  /** Options for execution */
+  options?: unknown;
+  /** Request type */
+  requestType?: 'WaitForEffectsCert' | 'WaitForLocalExecution';
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+/**
+ * Output for legacy sui:signAndExecuteTransactionBlock feature.
+ */
+interface SuiSignAndExecuteTransactionBlockOutput extends SuiSignAndExecuteTransactionOutput {}
+/**
+ * Wallet change event properties.
+ */
+interface SuiWalletChangeProperties {
+  chains?: readonly SuiChain[];
+  accounts?: readonly SuiAccount[];
+  features?: Record<string, unknown>;
+}
+/**
+ * Event listener types.
+ */
+type SuiWalletEventListener = (properties: SuiWalletChangeProperties) => void;
+/**
+ * Wallet icon type (data URL).
+ */
+type WalletIcon = `data:image/${'svg+xml' | 'webp' | 'png' | 'gif'};base64,${string}`;
+/**
+ * Wallet Standard features object.
+ */
+interface WaaPSuiWalletFeatures {
+  'standard:connect': {
+    version: '1.0.0';
+    connect: (input?: SuiConnectInput) => Promise<SuiConnectOutput>;
+  };
+  'standard:disconnect': {
+    version: '1.0.0';
+    disconnect: () => Promise<void>;
+  };
+  'standard:events': {
+    version: '1.0.0';
+    on: (event: 'change', listener: SuiWalletEventListener) => () => void;
+  };
+  'sui:signPersonalMessage': {
+    version: '1.1.0';
+    signPersonalMessage: (input: SuiSignPersonalMessageInput) => Promise<SuiSignPersonalMessageOutput>;
+  };
+  'sui:signTransaction': {
+    version: '2.0.0';
+    signTransaction: (input: SuiSignTransactionInput) => Promise<SuiSignTransactionOutput>;
+  };
+  'sui:switchChain': {
+    version: '1.0.0';
+    switchChain: (input: {
+      chain: SuiChain;
+    }) => Promise<void>;
+  };
+  'sui:signAndExecuteTransaction': {
+    version: '1.0.0';
+    signAndExecuteTransaction: (input: SuiSignAndExecuteTransactionInput) => Promise<SuiSignAndExecuteTransactionOutput>;
+  };
+  'sui:signTransactionBlock': {
+    version: '2.0.0';
+    signTransactionBlock: (input: SuiSignTransactionBlockInput) => Promise<SuiSignTransactionBlockOutput>;
+  };
+  'sui:signAndExecuteTransactionBlock': {
+    version: '1.0.0';
+    signAndExecuteTransactionBlock: (input: SuiSignAndExecuteTransactionBlockInput) => Promise<SuiSignAndExecuteTransactionBlockOutput>;
+  };
+}
+/**
+ * WaaP Sui Wallet interface.
+ */
+interface WaaPSuiWalletInterface {
+  /** Wallet name */
+  readonly name: string;
+  /** Wallet version */
+  readonly version: string;
+  /** Wallet icon */
+  readonly icon: WalletIcon;
+  /** Supported chains */
+  readonly chains: readonly SuiChain[];
+  /** Connected accounts */
+  readonly accounts: readonly SuiAccount[];
+  /** Public-safe local connection status for this facade. */
+  getAccountStatus(): WaaPAccountStatus;
+  session: WaaPSessionExtension;
+  /** Wallet Standard features */
+  readonly features: WaaPSuiWalletFeatures;
+  /**
+   * Connect to the wallet.
+   */
+  connect(input?: SuiConnectInput): Promise<SuiConnectOutput>;
+  /** Open the WaaP login flow without connecting this chain facade. */
+  login(): Promise<LoginResponse>;
+  /** End the WaaP session without implying a chain disconnect is a logout. */
+  logout(): Promise<void>;
+  getLoginMethod(): LoginResponse;
+  /**
+   * Disconnect from the wallet.
+   */
+  disconnect(): Promise<void>;
+  /** Release SDK message listeners owned by this Sui facade. */
+  destroy(): void;
+  /** Mount (if deferred) and complete the wallet handshake ahead of use. */
+  preload(): Promise<void>;
+  /**
+   * Switch the active chain.
+   */
+  switchChain(input: {
+    chain: SuiChain;
+  }): Promise<void>;
+  /**
+   * Sign a personal message.
+   */
+  signPersonalMessage(input: SuiSignPersonalMessageInput): Promise<SuiSignPersonalMessageOutput>;
+  /**
+   * Sign a BCS-serialized transaction without broadcasting it.
+   */
+  signTransaction(input: SuiSignTransactionInput): Promise<SuiSignTransactionOutput>;
+  /**
+   * Sign and execute a transaction.
+   */
+  signAndExecuteTransaction(input: SuiSignAndExecuteTransactionInput): Promise<SuiSignAndExecuteTransactionOutput>;
+  /**
+   * Sign a transaction block (Legacy).
+   */
+  signTransactionBlock(input: SuiSignTransactionBlockInput): Promise<SuiSignTransactionBlockOutput>;
+  /**
+   * Sign and execute a transaction block (Legacy).
+   */
+  signAndExecuteTransactionBlock(input: SuiSignAndExecuteTransactionBlockInput): Promise<SuiSignAndExecuteTransactionBlockOutput>;
+  /**
+   * Subscribe to wallet events. Supports the Wallet-Standard `change` event
+   * plus EVM-style `connect` / `accountsChanged` (so cross-chain hooks like
+   * `useWaapAuth` can subscribe to any facade uniformly).
+   * @returns Unsubscribe function
+   */
+  on(event: 'change', listener: SuiWalletEventListener): () => void;
+  on(event: string, listener: (...args: any[]) => void): () => void;
+  /** Remove a `connect` / `accountsChanged` listener. */
+  removeListener(event: string, listener: (...args: any[]) => void): void;
+  /** custom WaaP features */
+  /**
+   * Request the user's email address.
+   * @returns Promise resolving to the user's email address
+   */
+  requestEmail(): Promise<string>;
+  /**
+   * Request a Permission Token from the user.
+   * Allows pre-authorised batches of Sui transactions without individual confirmations.
+   *
+   * @param params - Allowed addresses, chainId (e.g. "sui:mainnet"), spend limit, expiry
+   * @returns Promise resolving to a RequestPermissionTokenResult
+   */
+  requestPermissionToken(params: RequestPermissionTokenParams): Promise<RequestPermissionTokenResult>;
+  getPermissionTokenStatus(query: PermissionTokenQuery): Promise<PermissionTokenStatus>;
+  clearPermissionToken(query: PermissionTokenQuery): Promise<PermissionTokenClearResult>;
+}
+/**
+ * Sui-supported authentication methods (no 'wallet/walletconnect' support yet)
+ * Also it is not necessary as @mysten/dapp-kit handles wallet choices
+ * todo: maybe add a modal to list out Sui wallets discovered as per Wallet Standard
+ */
+type SuiAuthenticationMethod = Exclude<AuthenticationMethod, 'wallet'>;
+/**
+ * Sui-specific custom configuration
+ */
+interface SuiCustomConfig extends Omit<CustomConfig, 'authenticationMethods'> {
+  authenticationMethods?: SuiAuthenticationMethod[];
+}
+/**
+ * Initialization options for WaaP Sui Wallet.
+ */
+interface InitWaaPSuiOptions extends WaaPWalletTargetOptions {
+  /** WaaP points referral code */
+  referralCode?: string;
+  /** WaaP project configuration */
+  project?: ProjectConfig;
+  /** WaaP custom UI configuration */
+  config?: SuiCustomConfig;
+  /** Wallet session transport; defaults to DPoP, with explicit bearer fallback. */
+  sessionProtection?: WaaPSessionProtection;
+  /**
+   * Defer iframe navigation until `preload()` or the first wallet operation.
+   * The default warms the iframe at browser idle; pass `false` to mount eagerly.
+   */
+  deferIframe?: boolean;
+}
+//#endregion
+//#region src/lib/solana/types.d.ts
+/** A Solana cluster identifier (CAIP-2-ish, matching wallet-adapter usage). */
+type SolanaChain = 'solana:mainnet' | 'solana:devnet' | 'solana:testnet' | 'solana:localnet';
+/** A connected Solana account. */
+interface SolanaAccount {
+  /** base58-encoded address. */
+  address: string;
+  /** Raw 32-byte ed25519 public key. */
+  publicKey: Uint8Array;
+  chains: readonly SolanaChain[];
+  features: readonly `${string}:${string}`[];
+}
+/** Public Wallet Standard features supported by the WaaP Solana wallet. */
+type WaaPSolanaWalletFeatures = {
+  'standard:connect': {
+    version: '1.0.0';
+    connect: (input?: {
+      silent?: boolean;
+    }) => Promise<SolanaConnectOutput>;
+  };
+  'standard:disconnect': {
+    version: '1.0.0';
+    disconnect: () => Promise<void>;
+  };
+  'standard:events': {
+    version: '1.0.0';
+    on: (event: 'change', listener: SolanaWalletEventListener) => () => void;
+  };
+  'solana:signMessage': {
+    version: '1.1.0';
+    signMessage: (...inputs: readonly SolanaStandardSignMessageInput[]) => Promise<readonly SolanaStandardSignMessageOutput[]>;
+  };
+  'solana:signTransaction': {
+    version: '1.0.0';
+    supportedTransactionVersions: readonly ('legacy' | 0)[];
+    signTransaction: (...inputs: readonly SolanaStandardSignTransactionInput[]) => Promise<readonly SolanaStandardSignTransactionOutput[]>;
+  };
+  'solana:signAndSendTransaction': {
+    version: '1.0.0';
+    supportedTransactionVersions: readonly ('legacy' | 0)[];
+    signAndSendTransaction: (...inputs: readonly SolanaStandardSignAndSendTransactionInput[]) => Promise<readonly SolanaStandardSignAndSendTransactionOutput[]>;
+  };
+};
+/** Solana Wallet Standard's variadic message-signing input. */
+interface SolanaStandardSignMessageInput {
+  account: SolanaAccount;
+  message: Uint8Array;
+}
+interface SolanaStandardSignMessageOutput {
+  signedMessage: Uint8Array;
+  signature: Uint8Array;
+  signatureType?: 'ed25519';
+}
+/** Solana Wallet Standard's serialized-transaction signing input. */
+interface SolanaStandardSignTransactionInput {
+  account: SolanaAccount;
+  transaction: Uint8Array;
+  chain?: SolanaChain;
+  options?: {
+    preflightCommitment?: 'processed' | 'confirmed' | 'finalized';
+    minContextSlot?: number;
+  };
+}
+interface SolanaStandardSignTransactionOutput {
+  signedTransaction: Uint8Array;
+}
+interface SolanaStandardSignAndSendTransactionInput extends SolanaStandardSignTransactionInput {
+  chain: SolanaChain;
+  options?: SolanaStandardSignTransactionInput['options'] & {
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    skipPreflight?: boolean;
+    maxRetries?: number;
+  };
+}
+interface SolanaStandardSignAndSendTransactionOutput {
+  signature: Uint8Array;
+}
+interface SolanaConnectInput {
+  /** Silent (non-interactive) reconnect. */
+  silent?: boolean;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+interface SolanaConnectOutput {
+  accounts: readonly SolanaAccount[];
+}
+interface SolanaSignMessageInput {
+  message: Uint8Array;
+  account: SolanaAccount;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+interface SolanaSignMessageOutput {
+  /** The message that was signed. */
+  signedMessage: Uint8Array;
+  /** The 64-byte ed25519 signature. */
+  signature: Uint8Array;
+}
+interface SolanaSignTransactionInput {
+  /** A serialized VersionedTransaction (bytes) or a `@solana/web3.js` tx object. */
+  transaction: Uint8Array | {
+    serialize(): Uint8Array;
+  };
+  account: SolanaAccount;
+  chain?: SolanaChain;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  /** Use a matching permission token when the wallet has one. */
+  withPT?: boolean;
+}
+interface SolanaSignTransactionOutput {
+  /** The signed, serialized transaction bytes. */
+  signedTransaction: Uint8Array;
+  /** The 64-byte ed25519 signature. */
+  signature: Uint8Array;
+}
+interface SolanaSignAndSendTransactionInput extends SolanaSignTransactionInput {
+  options?: {
+    skipPreflight?: boolean;
+    maxRetries?: number;
+  };
+}
+interface SolanaSignAndSendTransactionOutput {
+  /** base58 transaction signature (the on-chain txid). */
+  signature: string;
+}
+type SolanaWalletEventListener = (properties: {
+  chains?: readonly SolanaChain[];
+  features?: WaaPSolanaWalletFeatures;
+  accounts?: readonly SolanaAccount[];
+}) => void;
+interface InitWaaPSolanaOptions extends WaaPWalletTargetOptions {
+  referralCode?: string;
+  project?: ProjectConfig;
+  config?: CustomConfig;
+  /** Wallet session transport; defaults to DPoP, with explicit bearer fallback. */
+  sessionProtection?: WaaPSessionProtection;
+  /**
+   * Defer iframe navigation until `preload()` or the first wallet operation.
+   * The default warms the iframe at browser idle; pass `false` to mount eagerly.
+   */
+  deferIframe?: boolean;
+}
+interface WaaPSolanaProviderInterface {
+  readonly name: string;
+  readonly version: string;
+  /** Wallet Standard icon data URI. */
+  readonly icon: `data:image/${'svg+xml' | 'webp' | 'png' | 'gif'};base64,${string}`;
+  readonly chains: readonly SolanaChain[];
+  readonly accounts: readonly SolanaAccount[];
+  /** Wallet Standard capabilities exposed by this Solana facade. */
+  readonly features: WaaPSolanaWalletFeatures;
+  /** Public-safe local connection status for this facade. */
+  getAccountStatus(): WaaPAccountStatus;
+  session: WaaPSessionExtension;
+  /** Open the WaaP login flow without connecting this chain facade. */
+  login(): Promise<LoginResponse>;
+  /** End the WaaP session without implying a chain disconnect is a logout. */
+  logout(): Promise<void>;
+  getLoginMethod(): LoginResponse;
+  connect(input?: SolanaConnectInput): Promise<SolanaConnectOutput>;
+  disconnect(): Promise<void>;
+  /** Release SDK message listeners owned by this Solana facade. */
+  destroy(): void;
+  /** Mount (if deferred) and complete the wallet handshake ahead of use. */
+  preload(): Promise<void>;
+  signMessage(input: SolanaSignMessageInput): Promise<SolanaSignMessageOutput>;
+  signTransaction(input: SolanaSignTransactionInput): Promise<SolanaSignTransactionOutput>;
+  signAndSendTransaction(input: SolanaSignAndSendTransactionInput): Promise<SolanaSignAndSendTransactionOutput>;
+  requestPermissionToken(params: RequestPermissionTokenParams): Promise<RequestPermissionTokenResult>;
+  getPermissionTokenStatus(query: PermissionTokenQuery): Promise<PermissionTokenStatus>;
+  clearPermissionToken(query: PermissionTokenQuery): Promise<PermissionTokenClearResult>;
+  /**
+   * Subscribe to wallet events. Supports `change` plus EVM-style `connect` /
+   * `accountsChanged` (so cross-chain hooks like `useWaapAuth` can subscribe to
+   * any facade uniformly).
+   * @returns Unsubscribe function
+   */
+  on(event: 'change', listener: SolanaWalletEventListener): () => void;
+  on(event: string, listener: (...args: any[]) => void): () => void;
+  /** Remove a `connect` / `accountsChanged` listener. */
+  removeListener(event: string, listener: (...args: any[]) => void): void;
+}
+//#endregion
+//#region src/ui/index.d.ts
+/** Chain selected by a direct WaaP initializer. */
+type WaaPChain = 'evm' | 'sui' | 'solana';
+/**
+ * Shared options for the direct WaaP initializers.
+ *
+ * This deliberately has no chain selector so the published `2.0.0`
+ * `InitWaaPOptions` remains assignable to the legacy EVM overload.
+ */
+interface InitWaaPOptions extends Omit<InitWaaPSuiOptions, 'config'> {
+  /** Shared wallet configuration; EVM may additionally allow `wallet`. */
+  config?: InitSilkOptions['config'];
+  /** WalletConnect project ID (required only when offering the `wallet` auth method). */
+  walletConnectProjectId?: string;
+  /** Forwarded to the EVM provider: resolve eth_sendTransaction on tx-hash. */
+  asyncTxs?: boolean;
+  /** @deprecated Use `asyncTxs` instead. */
+  asyncSigning?: boolean;
+}
+/**
+ * `InitWaaPOptions` plus a direct native-chain selector.
+ *
+ * Omit `chain` to retain the published EVM EIP-1193 return type.
+ */
+interface InitWaaPChainOptions extends InitWaaPOptions {
+  chain?: WaaPChain;
+}
+type LegacyInitWaaPEvmOptions = InitWaaPOptions & {
+  chain?: 'evm';
+};
+type LegacyInitWaaPSuiOptions = Omit<InitWaaPChainOptions, 'chain' | 'config'> & {
+  chain: 'sui';
+  config?: InitWaaPSuiOptions['config'];
+};
+type LegacyInitWaaPSolanaOptions = InitWaaPChainOptions & {
+  chain: 'solana';
+};
+/**
+ * Initialize the TAP wallet.
+ *
+ * Existing `initWaaP(options)` calls retain their EVM provider behavior. Use
+ * `chain: 'sui'` or `chain: 'solana'` to select a direct Wallet Standard
+ * facade. Use `initWaaPMulti({ chains })` for a shared multichain wallet.
+ */
+declare function initWaaP(options?: LegacyInitWaaPEvmOptions): SilkEthereumProviderInterface;
+declare function initWaaP(options: LegacyInitWaaPSuiOptions): WaaPSuiWalletInterface;
+declare function initWaaP(options: LegacyInitWaaPSolanaOptions): WaaPSolanaProviderInterface;
+/** Accepts a runtime-selected chain when callers cannot preserve a literal. */
+declare function initWaaP(options: InitWaaPChainOptions): SilkEthereumProviderInterface | WaaPSuiWalletInterface | WaaPSolanaProviderInterface;
+/**
+ * Options for the multichain `initWaaPSquid` entry point.
+ *
+ * "Squid" is the public brand name for WaaP's pre-created shared-dwallet
+ * signing (IKA LITE). It is NOT the deprecated per-user-DKG engine — the
+ * internals run exclusively through the lite flow.
+ *
+ * Extends the Sui options with the EVM-side `walletConnectProjectId` and
+ * `asyncTxs` — both are forwarded to the underlying EVM provider (they were
+ * previously dropped). `deferIframe` is supported across the shared facades;
+ * call `preload()` after the host application's LCP to warm it explicitly.
+ */
+interface InitWaaPSquidOptions extends InitWaaPSuiOptions {
+  /**
+   * Chain facades to expose. Defaults to all three Squid chains; this scopes
+   * SDK/UI loading, not the current dual-curve Squid provisioning transaction.
+   */
+  chains?: readonly WaaPSquidChain[];
+  /** WalletConnect project ID (required only when offering the `wallet` auth method). */
+  walletConnectProjectId?: string;
+  /** Forwarded to the EVM provider: resolve eth_sendTransaction on tx-hash. */
+  asyncTxs?: boolean;
+}
+type WaaPSquidChain = 'evm' | 'sui' | 'solana';
+declare const ALL_SQUID_CHAINS: readonly ["evm", "sui", "solana"];
+/** Public, non-secret lifecycle of the two-curve Squid account. */
+type WaaPSquidStatusState = 'absent' | 'provisioning' | 'awaiting-network' | 'active' | 'failed';
+interface WaaPSquidStatus {
+  state: WaaPSquidStatusState;
+  /** Public create-transaction digest; usable as the current operation ID. */
+  operationId?: string;
+  transactionDigest?: string;
+  message?: string;
+}
+/**
+ * Options for the multichain TAP entry point.
+ *
+ * Unlike calling independent chain initializers, `initWaaPMulti({ chains })`
+ * makes their facades share one wallet iframe and one authenticated session.
+ * It is useful to applications which present all supported TAP chains in one
+ * surface, while `initWaaP({ chain: 'sui' })` remains the best choice for a
+ * single-chain integration.
+ */
+interface InitWaaPMultiOptions extends InitWaaPOptions {
+  /** Chain facades to expose from one shared wallet iframe. */
+  chains: readonly WaaPChain[];
+}
+/** @deprecated Use `InitWaaPMultiOptions`. */
+type InitWaaPTapOptions = InitWaaPMultiOptions;
+declare const ALL_TAP_CHAINS: readonly ["evm", "sui", "solana"];
+type FacadeFor<Chains extends readonly WaaPSquidChain[], Chain extends WaaPSquidChain, Facade> = Chain extends Chains[number] ? Facade : Record<never, never>;
+type LegacyAuthFor<Chains extends readonly WaaPSquidChain[]> = WaaPSquidChain extends Chains[number] ? {
+  /**
+   * @deprecated Use the chain-neutral `session` event surface instead.
+   * This EVM alias remains for all-chain integrations.
+   */
+  auth: SilkEthereumProviderInterface;
+} : Record<never, never>;
+/** Chain-neutral authentication and lifecycle events for a Squid wallet. */
+interface WaaPSquidSession extends WaaPSessionExtension {
+  /** Read the public Squid lifecycle from this shared SDK controller. */
+  getSquidStatus(): WaaPSquidStatus;
+  on(event: string, listener: (...args: any[]) => void): WaaPSquidSession;
+  removeListener(event: string, listener: (...args: any[]) => void): WaaPSquidSession;
+}
+/** Explicit Squid account lifecycle, separate from chain-specific facades. */
+interface WaaPSquidLifecycle {
+  /** Create or restore the required Squid signing entries after login. */
+  onboard(): Promise<void>;
+  /** Read the current public lifecycle without exposing wallet internals. */
+  getStatus(): WaaPSquidStatus;
+  /** Trigger onboarding and return the immediately observable lifecycle. */
+  onboardWithStatus(): Promise<WaaPSquidStatus>;
+}
+/** Chain-neutral authentication and lifecycle events for a TAP wallet. */
+interface WaaPTapSession extends WaaPSessionExtension {
+  on(event: string, listener: (...args: any[]) => void): WaaPTapSession;
+  removeListener(event: string, listener: (...args: any[]) => void): WaaPTapSession;
+}
+/**
+ * The multichain surface returned by `initWaaPMulti({ chains })`.
+ *
+ * All selected facades use one wallet iframe, so a single login establishes
+ * the session consumed by EVM, Sui, and Solana. TAP does not have a separate
+ * provisioning step; connect and sign through the requested native facade.
+ */
+type WaaPTap<Chains extends readonly WaaPChain[] = typeof ALL_TAP_CHAINS> = {
+  /** Combined public-safe local status for the shared TAP initializer. */
+  getAccountStatus: () => WaaPAccountStatus;
+  /** Shared canonical authentication, status, and lifecycle event surface. */
+  session: WaaPTapSession;
+  /** Mount (if deferred) and complete the shared iframe handshake. */
+  preload: () => Promise<void>;
+  /** Release all facades and their shared wallet iframe. */
+  destroy: () => void;
+} & FacadeFor<Chains, 'evm', {
+  /** EIP-1193 provider (EVM). */ evm: SilkEthereumProviderInterface;
+  /** @deprecated Use `evm`. */ ethereum: SilkEthereumProviderInterface;
+}> & FacadeFor<Chains, 'sui', {
+  sui: WaaPSuiWalletInterface;
+}> & FacadeFor<Chains, 'solana', {
+  /** Solana Wallet Standard adapter. */ solana: WaaPSolanaProviderInterface;
+}>;
+/**
+ * The multichain surface returned by `initWaaPSquid`.
+ *
+ * All three chain facades share ONE wallet iframe. Squid account creation is
+ * explicit: call `onboard()` after login. Initialization and login alone never
+ * create a shared-DWallet account.
+ *
+ * ### Events
+ * All three facades emit `connect` and `accountsChanged` on a successful
+ * (non-silent) `connect()`/`login()`, so `useWaapAuth` and similar hooks work
+ * against any of them. The Sui/Solana facades additionally emit the
+ * Wallet-Standard `change` event; subscribe with `.on(event, listener)` and
+ * unsubscribe via the returned fn or `.removeListener(event, listener)`.
+ *
+ * ### Error style
+ * - `ethereum` follows EIP-1193: rejected requests surface the provider error
+ *   object (`{ code, message, ... }`) per spec — match on `error.code`.
+ * - `sui` / `solana` throw `WaaPError` at the iframe transport boundary. Its
+ *   stable `code` and optional operation metadata make cancellation, timeout,
+ *   user/policy rejection, and wallet errors safe to handle programmatically.
+ */
+type WaaPSquid<Chains extends readonly WaaPSquidChain[] = typeof ALL_SQUID_CHAINS> = {
+  /**
+   * Explicitly create or restore the Squid account for both curves. Call this
+   * after login and before connecting or signing through a Squid facade.
+   */
+  onboard: () => Promise<void>;
+  /** Preferred explicit owner of Squid onboarding. */
+  squid: WaaPSquidLifecycle;
+  /** Read the lifecycle of the two-curve Squid account. */
+  getSquidStatus: () => WaaPSquidStatus;
+  /** Combined public-safe local status for the one Squid initializer family. */
+  getAccountStatus: () => WaaPAccountStatus;
+  /** Shared canonical authentication, status, and lifecycle event surface. */
+  session: WaaPSquidSession;
+  /** Mount (if deferred) and complete the shared iframe handshake. */
+  preload: () => Promise<void>;
+  /** Release all three facades and their shared wallet iframe. */
+  destroy: () => void;
+} & FacadeFor<Chains, 'evm', {
+  /** EIP-1193 provider (EVM). */ evm: SilkEthereumProviderInterface;
+  /** @deprecated Use `evm`. */ ethereum: SilkEthereumProviderInterface;
+}> & FacadeFor<Chains, 'sui', {
+  sui: WaaPSuiWalletInterface;
+}> & FacadeFor<Chains, 'solana', {
+  /** Solana Wallet Standard adapter. */ solana: WaaPSolanaProviderInterface;
+}> & LegacyAuthFor<Chains>;
+/**
+ * Initialize the multichain WaaP "Squid" wallet (EVM + Sui + Solana).
+ *
+ * Creates a single wallet iframe and returns the chain facades plus an
+ * `onboard()` trigger. Internals use the Lite protocol core
+ * (`@human.tech/ika-lite`) through the wallet's Squid adapter and `signLite` —
+ * never the deprecated per-user-DKG engine.
+ *
+ * @example
+ * ```ts
+ * const waap = initWaaPSquid({ chains: ['evm', 'sui'] })
+ * await waap.session.login()
+ * await waap.squid.onboard()       // explicit create/restore for sqd1 + sqd2
+ * const { accounts } = await waap.sui.connect()
+ * ```
+ */
+declare function initWaaPSquid<const Chains extends readonly WaaPSquidChain[]>(options: InitWaaPSquidOptions & {
+  chains: Chains;
+}): WaaPSquid<Chains>;
+declare function initWaaPSquid(options?: InitWaaPSquidOptions): WaaPSquid;
+/**
+ * Initialize a shared multichain TAP wallet. TAP accounts are restored by the
+ * normal authenticated wallet session.
+ *
+ * @example
+ * ```ts
+ * const waap = initWaaPMulti({ chains: ['evm', 'sui', 'solana'] })
+ * await waap.session.login()
+ * const { accounts } = await waap.sui.connect()
+ * ```
+ */
+declare function initWaaPMulti<const Chains extends readonly WaaPChain[]>(options: InitWaaPMultiOptions & {
+  chains: Chains;
+}): WaaPTap<Chains>;
+/**
+ * @deprecated Use `initWaaP({ chain: 'sui' })` instead.
+ *
+ * This compatibility wrapper keeps the standalone Sui Wallet Standard return
+ * shape while routing through the one TAP composition path.
+ */
+declare function initWaaPSui(options?: InitWaaPSuiOptions): WaaPSuiWalletInterface;
+/**
+ * @deprecated Use `initWaaP({ chain: 'solana' })` instead.
+ *
+ * Keeps the legacy standalone Wallet Standard return shape for existing apps.
+ */
+declare function initWaaPSolana(options?: InitWaaPSolanaOptions): WaaPSolanaProviderInterface;
+/** @deprecated Use `initWaaPMulti({ chains })` instead. */
+declare function initWaaPTap<const Chains extends readonly WaaPChain[]>(options: InitWaaPTapOptions & {
+  chains: Chains;
+}): WaaPTap<Chains>;
+declare function initWaaPTap(options?: Partial<InitWaaPTapOptions>): WaaPTap;
+//#endregion
+export { SuiSignTransactionBlockOutput as $, SolanaSignTransactionInput as A, WaaPSolanaWalletFeatures as B, SolanaChain as C, SolanaSignAndSendTransactionOutput as D, SolanaSignAndSendTransactionInput as E, SolanaStandardSignMessageOutput as F, SuiConnectOutput as G, SuiAccount as H, SolanaStandardSignTransactionInput as I, SuiSignAndExecuteTransactionInput as J, SuiSignAndExecuteTransactionBlockInput as K, SolanaStandardSignTransactionOutput as L, SolanaStandardSignAndSendTransactionInput as M, SolanaStandardSignAndSendTransactionOutput as N, SolanaSignMessageInput as O, SolanaStandardSignMessageInput as P, SuiSignTransactionBlockInput as Q, SolanaWalletEventListener as R, SolanaAccount as S, SolanaConnectOutput as T, SuiChain as U, InitWaaPSuiOptions as V, SuiConnectInput as W, SuiSignPersonalMessageInput as X, SuiSignAndExecuteTransactionOutput as Y, SuiSignPersonalMessageOutput as Z, initWaaPSolana as _, InitWaaPTapOptions as a, WaaPSuiWalletInterface as at, initWaaPTap as b, WaaPSquidChain as c, WaaPSquidStatus as d, SuiSignTransactionInput as et, WaaPSquidStatusState as f, initWaaPMulti as g, initWaaP as h, InitWaaPSquidOptions as i, WaaPSuiWalletFeatures as it, SolanaSignTransactionOutput as j, SolanaSignMessageOutput as k, WaaPSquidLifecycle as l, WaaPTapSession as m, InitWaaPMultiOptions as n, SuiTransactionInput as nt, WaaPChain as o, WalletIcon as ot, WaaPTap as p, SuiSignAndExecuteTransactionBlockOutput as q, InitWaaPOptions as r, SuiWalletEventListener as rt, WaaPSquid as s, InitWaaPChainOptions as t, SuiSignTransactionOutput as tt, WaaPSquidSession as u, initWaaPSquid as v, SolanaConnectInput as w, InitWaaPSolanaOptions as x, initWaaPSui as y, WaaPSolanaProviderInterface as z };