@flarenetwork/multichain-wallet-connector 0.0.1-rc.0

package/dist/utils-C64Z4fWz.d.mts

@@ -0,0 +1,974 @@
+import { Account, Address, EIP1193Provider, PublicClient, RpcError, WalletClient } from "viem";
+import { Client, SubmittableTransaction } from "xrpl";
+import Xrp from "@ledgerhq/hw-app-xrp";
+import UniversalProvider from "@walletconnect/universal-provider";
+import { Xumm } from "xumm";
+import * as _xstate_store0 from "@xstate/store";
+import { ExtractEvents, Subscription } from "@xstate/store";
+import { createBrowserInspector } from "@statelyai/inspect";
+
+//#region src/core/shared/type-utils.d.ts
+type NonEmptyArray<T> = [T, ...T[]];
+//#endregion
+//#region src/core/chains/chain.constants.d.ts
+declare const CAIP2_NAMESPACES: {
+  readonly eip155: "eip155";
+  readonly xrpl: "xrpl";
+  readonly bip122: "bip122";
+};
+declare const CAIP2: {
+  readonly eip155: {
+    readonly "1": "Ethereum Mainnet";
+    readonly "11155111": "Ethereum Sepolia";
+    readonly "14": "Flare Mainnet";
+    readonly "16": "Flare Testnet Coston";
+    readonly "114": "Flare Testnet Coston2";
+    readonly "19": "Songbird Canary-Network";
+  };
+  readonly xrpl: {
+    readonly "0": "XRP Ledger Mainnet";
+    readonly "1": "XRP Ledger Testnet";
+  };
+  readonly bip122: {
+    readonly "1a91e3dace36e2be3bf030a65679fe821": "Dogecoin Mainnet";
+  };
+};
+//#endregion
+//#region src/core/chains/chain.types.d.ts
+type InferCaip2FromReferences<T> = { [N in keyof T]: { [R in keyof T[N]]: `${N & string}:${R & string}` }[keyof T[N]] }[keyof T];
+type Caip2 = InferCaip2FromReferences<typeof CAIP2>;
+type Caip2Namespace = keyof typeof CAIP2_NAMESPACES;
+type ExtractNamespace<C extends Caip2> = C extends `${infer N}:${string}` ? N : never;
+type GetChainName<C extends Caip2> = C extends `${infer N}:${infer R}` ? N extends keyof typeof CAIP2 ? R extends keyof (typeof CAIP2)[N] ? (typeof CAIP2)[N][R] : never : never : never;
+interface BaseChain<C extends Caip2 = Caip2> {
+  caip2: C;
+  name: GetChainName<C>;
+  namespace: ExtractNamespace<C>;
+  nativeCurrency: {
+    name: string;
+    symbol: string;
+    decimals: number;
+  };
+  rpcUrls: NonEmptyArray<string>;
+  isEvm: boolean;
+  blockExplorerUrls: NonEmptyArray<string>;
+  ledgerHrp?: string;
+  bip44Part: number;
+  testnet: boolean;
+}
+type EvmChain<ID = string, HEX = string> = BaseChain<Extract<Caip2, `eip155:${string}`>> & {
+  evmChain: {
+    id: ID;
+    hex: HEX;
+  };
+  isEvm: true;
+};
+type NonEvmChain = BaseChain<Exclude<Caip2, `eip155:${string}`>> & {
+  isEvm: false;
+};
+type XrplChain = BaseChain<XRPlCaip2> & {
+  isEvm: false;
+};
+type Chain = EvmChain | NonEvmChain;
+type ChainConfig = { [K in Caip2]: K extends `eip155:${string}` ? EvmChain & {
+  caip2: K;
+} : NonEvmChain & {
+  caip2: K;
+} };
+type NamespaceFilter<T, NAMESPACE extends string> = T extends `${NAMESPACE}:${string}` ? T : never;
+type Eip155Caip2 = NamespaceFilter<Caip2, "eip155">;
+type XRPlCaip2 = NamespaceFilter<Caip2, "xrpl">;
+//#endregion
+//#region src/core/wallets/wallet-registry.d.ts
+declare const walletRegistry: {
+  readonly metamask: {
+    readonly label: "MetaMask";
+    readonly chains: Eip155Caip2[];
+    readonly canConnect: "single-at-once";
+  };
+  readonly "wallet-connect": {
+    readonly label: "WalletConnect";
+    readonly chains: readonly [...Eip155Caip2[], "xrpl:0", "xrpl:1"];
+    readonly canConnect: "all-at-once";
+  };
+  readonly ledger: {
+    readonly label: "Ledger";
+    readonly chains: readonly ["eip155:1", "eip155:11155111", "eip155:14", "eip155:16", "eip155:114", "eip155:19", "xrpl:0", "xrpl:1"];
+    readonly canConnect: "single-at-once";
+  };
+  readonly xaman: {
+    readonly label: "Xaman";
+    readonly chains: readonly ["xrpl:0", "xrpl:1"];
+    readonly canConnect: "single-at-once";
+  };
+  readonly dcent: {
+    readonly label: "D'CENT";
+    readonly chains: readonly ["xrpl:0", "xrpl:1"];
+    readonly canConnect: "single-at-once";
+  };
+};
+//#endregion
+//#region src/core/wallets/wallet.types.d.ts
+type WalletType = keyof typeof walletRegistry;
+type WalletSupportForChain = { [K in WalletType]: {
+  chains: (typeof walletRegistry)[K]["chains"];
+  canConnect: (typeof walletRegistry)[K]["canConnect"];
+} };
+type WalletSupportedChainMap = WalletSupportForChain;
+type SupportedWalletChains<TYPE extends WalletType> = WalletSupportedChainMap[TYPE]["chains"] extends readonly (infer Item)[] ? NonEmptyArray<Item> : never;
+type ValidWalletsForChain<T extends Caip2> = { [K in WalletType]: T extends SupportedWalletChains<K>[number] ? K : never }[WalletType];
+//#endregion
+//#region src/core/stores/wallet-store/wallet-store.d.ts
+type WalletConnectionState = "disconnected" | "connecting" | "connected" | "disconnecting" | "error";
+interface WalletErrorState {
+  code: number | string;
+  message: string;
+}
+type WalletAddressState<T extends WalletType = WalletType> = Extract<{ [K in WalletType]: {
+  type: K;
+  address: string;
+} & {
+  isEvm: boolean;
+  caip2: Caip2;
+} }[WalletType], {
+  type: T;
+}>;
+interface WalletState {
+  connectionState: WalletConnectionState;
+  activeAddress: string | undefined;
+  availableAddresses: Array<WalletAddressState>;
+  caip2: Caip2 | undefined;
+  error: WalletErrorState | undefined;
+}
+type WalletStoreEvents = {
+  startConnecting: Record<never, never>;
+  connectionEstablished: {
+    activeAddress: string;
+    availableAddresses: Array<WalletAddressState>;
+    caip2: Caip2;
+  };
+  connectionRestored: {
+    activeAddress: string;
+    availableAddresses: Array<WalletAddressState>;
+    caip2: Caip2;
+  };
+  error: {
+    error: WalletErrorState;
+  };
+  startDisconnecting: Record<never, never>;
+  disconnected: Record<never, never>;
+  chainChanged: {
+    caip2: Caip2;
+  };
+  addressChanged: {
+    activeAddress: string;
+    availableAddresses: Array<WalletAddressState>;
+  };
+};
+type WalletStoreEmittedEvents = {
+  walletConnected: {
+    activeAddress: string;
+    availableAddresses: Array<WalletAddressState>;
+    caip2: Caip2;
+    walletType: WalletType;
+    isReconnect: boolean;
+  };
+  walletDisconnected: {
+    walletType: WalletType;
+  };
+  walletError: {
+    error: WalletErrorState;
+    walletType: WalletType;
+  };
+  walletChainChanged: {
+    caip2: Caip2;
+    walletType: WalletType;
+  };
+  walletAddressChanged: {
+    activeAddress: string;
+    walletType: WalletType;
+  };
+};
+type WalletEmittedEvent = ExtractEvents<WalletStoreEmittedEvents>;
+declare const createWalletStore: (walletType: WalletType) => _xstate_store0.Store<WalletState, WalletStoreEvents, ExtractEvents<WalletStoreEmittedEvents>>;
+type WalletStore = ReturnType<typeof createWalletStore>;
+//#endregion
+//#region src/core/config/config-types.d.ts
+interface ChainOverride {
+  rpcUrls?: string[];
+  blockExplorerUrls?: string[];
+}
+interface ResolvedWalletConfig<W extends WalletType = WalletType> {
+  readonly walletType: W;
+  readonly chains: Readonly<ChainConfig>;
+  readonly evmHexMap: ReadonlyMap<string, Eip155Caip2>;
+  getChain<C extends Caip2>(caip2: C): ChainConfig[C];
+  getEvmChain(caip2: Eip155Caip2): EvmChain;
+  getXrplChain(caip2: XRPlCaip2): XrplChain;
+  getRpcUrl(caip2: Caip2): string;
+  getSupportedChains(): Caip2[];
+}
+interface WalletMetadata {
+  name: string;
+  url: string;
+  description?: string;
+  icons?: string[];
+}
+interface WalletOptions {
+  metadata?: WalletMetadata;
+  chainOverrides?: Partial<Record<Caip2, ChainOverride>>;
+}
+interface MetaMaskWalletOptions extends WalletOptions {}
+interface WalletConnectWalletOptions extends WalletOptions {
+  projectId: string;
+}
+interface LedgerWalletOptions extends WalletOptions {}
+interface XamanWalletOptions extends WalletOptions {
+  apiKey: string;
+}
+interface DcentWalletOptions extends WalletOptions {}
+interface WalletOptionsMap {
+  metamask: MetaMaskWalletOptions;
+  "wallet-connect": WalletConnectWalletOptions;
+  ledger: LedgerWalletOptions;
+  xaman: XamanWalletOptions;
+  dcent: DcentWalletOptions;
+}
+interface ConnectEvent {
+  walletType: WalletType;
+  caip2: Caip2;
+  address: string;
+  availableAddresses: WalletAddressState[];
+  isReconnect: boolean;
+}
+interface DisconnectEvent {
+  walletType: WalletType;
+}
+interface ChainChangedEvent {
+  walletType: WalletType;
+  caip2: Caip2;
+}
+interface AccountChangedEvent {
+  walletType: WalletType;
+  address: string;
+}
+interface ErrorEvent {
+  walletType: WalletType;
+  error: Error;
+}
+interface MultiChainEvents {
+  onConnect?: (event: ConnectEvent) => void;
+  onDisconnect?: (event: DisconnectEvent) => void;
+  onChainChanged?: (event: ChainChangedEvent) => void;
+  onAccountChanged?: (event: AccountChangedEvent) => void;
+  onError?: (event: ErrorEvent) => void;
+}
+interface MultiChainOptions {
+  chainOverrides?: Partial<Record<Caip2, ChainOverride>>;
+  wallets: { [W in WalletType]?: WalletOptionsMap[W] };
+  events?: MultiChainEvents;
+}
+//#endregion
+//#region src/core/shared/bip44.d.ts
+declare class Bip44 {
+  private readonly _purpose;
+  private readonly _coinType;
+  private readonly _account;
+  private readonly _change;
+  private readonly _addressIndex;
+  constructor(path: LedgerDerivationPath | LedgerDerivationPathNoMaster);
+  get purpose(): number;
+  get coinType(): number;
+  get account(): number;
+  get change(): 0 | 1;
+  get addressIndex(): number;
+  /**
+   * Generate paginated BIP44 paths.
+   * - bip44 standard: m/44'/coin'/0'/0/i — increments address index
+   * - Ledger Live: m/44'/coin'/i'/0/0 — increments account
+   */
+  static getPaginatedBip44s({
+    from,
+    to,
+    ledgerHDStandard,
+    caip2
+  }: {
+    from: number;
+    to: number;
+    ledgerHDStandard: LedgerHDStandard;
+    caip2: Caip2;
+  }): LedgerPaginatedBip44;
+  static fromCaip2ToCoinType(caip2: Caip2): number;
+  static fromCaip2(caip2: Caip2, account?: number, change?: 0 | 1, addressIndex?: number): Bip44;
+  static fromCoin(coinType: number, account?: number, change?: 0 | 1, addressIndex?: number): Bip44;
+  static bitcoin(account?: number, change?: 0 | 1, addressIndex?: number): Bip44;
+  static ethereum(account?: number, change?: 0 | 1, addressIndex?: number): Bip44;
+  static ledgerLiveEthereum(accountIndex?: number): Bip44;
+  getIndexForStandard(standard: LedgerHDStandard): number;
+  isChangeAddress(): boolean;
+  isReceivingAddress(): boolean;
+  getFullPath(): LedgerDerivationPath;
+  getPathWithoutMaster(): LedgerDerivationPathNoMaster;
+  toPathArray(): number[];
+  deriveFromAddressIndex(newAddressIndex: number): Bip44;
+  nextAddress(standard?: LedgerHDStandard): Bip44;
+  toReceivingAddress(addressIndex?: number): Bip44;
+  toChangeAddress(addressIndex?: number): Bip44;
+  deriveAccount(accountIndex: number): Bip44;
+  toString(): string;
+  getNextPaginatedBip44s(caip2: Caip2, ledgerHDStandard: LedgerHDStandard): LedgerPaginatedBip44;
+  isValidCaip2(caip2: Caip2): boolean;
+  private parseComponent;
+  private hardenedValue;
+}
+//#endregion
+//#region src/core/connectors/ledger/ledger.types.d.ts
+/** Chain type for Ledger-supported chains */
+type LedgerCaip2 = SupportedWalletChains<"ledger">[number];
+type LedgerDerivationPathNoMaster = `44'/${number}'/${number}'/${0 | 1}/${number}`;
+type LedgerDerivationPath = `m/${LedgerDerivationPathNoMaster}`;
+type LedgerHDStandard = "bip44" | "ledgerLive";
+interface LedgerPaginatedBip44 {
+  paths: Array<Bip44>;
+  from: number;
+  to: number;
+  ledgerHDStandard: LedgerHDStandard;
+}
+interface CreateLedgerClientArgs {
+  app: LedgerApp;
+  caip2: LedgerCaip2;
+  bip44: Bip44;
+}
+interface LedgerConnectOptions {
+  bip44: Bip44;
+  ledgerHDStandard: LedgerHDStandard;
+}
+interface LedgerComputedAddress {
+  address: string;
+  publicKey?: string;
+  bip44: Bip44;
+}
+//#endregion
+//#region src/core/connectors/ledger/apps/ledger-app.d.ts
+interface LedgerApp {
+  getComputedAddress: (bip44: Bip44, hrp?: string) => Promise<LedgerComputedAddress>;
+  getComputedAddresses: (bip44: Array<Bip44>, hrp?: string) => Promise<Array<LedgerComputedAddress>>;
+}
+//#endregion
+//#region src/core/clients/client-types.d.ts
+interface ChainClient {
+  getBalance: (address: string) => Promise<bigint | number>;
+  onDestroy: () => Promise<void>;
+  getCaip2: () => Promise<Caip2>;
+}
+interface LedgerClient<APP extends LedgerApp = LedgerApp> extends ChainClient {
+  getLedgerApp: () => APP;
+}
+//#endregion
+//#region src/core/clients/base-evm-client.d.ts
+declare abstract class BaseEvmClient implements ChainClient {
+  protected readonly chainConfig: Chain;
+  constructor(chainConfig: Chain);
+  getCaip2(): Promise<Caip2>;
+  abstract getBalance(address: string): Promise<bigint | number>;
+  onDestroy(): Promise<void>;
+}
+//#endregion
+//#region src/core/clients/evm/evm-client.d.ts
+/**
+ * EVM chain client.
+ * Provides Viem public and wallet clients for EVM chain interactions.
+ */
+declare class EvmClient extends BaseEvmClient {
+  private readonly publicClient;
+  private readonly walletClient;
+  constructor(chainConfig: EvmChain, publicClient: PublicClient, walletClient: WalletClient);
+  /**
+   * Create an EVM client from chain config and provider.
+   */
+  static create(chainConfig: EvmChain, provider: EIP1193Provider): EvmClient;
+  /**
+   * Create an EVM client with HTTP transport (for read-only operations).
+   */
+  static createReadOnly(chainConfig: EvmChain): EvmClient;
+  getPublicClient(): PublicClient;
+  getWalletClient(): WalletClient;
+  getAccount(): Promise<Account | Address>;
+  /**
+   * Get balance for an address in wei.
+   */
+  getBalance(address: string): Promise<bigint>;
+  /**
+   * Get the EVM chain config.
+   */
+  get evmChainConfig(): EvmChain;
+}
+//#endregion
+//#region src/core/connectors/dcent/dcent.types.d.ts
+interface DcentWalletInfo {
+  name: string;
+  icon: string;
+  version: string;
+  chainId: string;
+}
+interface DcentXrplProvider {
+  getWalletInfo(): Promise<DcentWalletInfo>;
+  request<T>(args: {
+    method: string;
+    params?: unknown[] | object;
+  }): Promise<T>;
+}
+declare global {
+  interface Window {
+    xrpl?: DcentXrplProvider;
+  }
+} //# sourceMappingURL=dcent.types.d.ts.map
+//#endregion
+//#region src/core/connectors/connector-events.d.ts
+interface ConnectedEventData {
+  address: string;
+  addresses: string[] | WalletAddressState[];
+  caip2: Caip2;
+}
+interface AddressChangedEventData {
+  address: string;
+  addresses: string[] | WalletAddressState[];
+  caip2: Caip2;
+}
+declare class ConnectorEventEmitter {
+  private readonly store;
+  private readonly walletType;
+  constructor(store: WalletStore, walletType: WalletType);
+  startConnecting(): void;
+  connected(data: ConnectedEventData): void;
+  reconnected(data: ConnectedEventData): void;
+  startDisconnecting(): void;
+  disconnected(): void;
+  chainChanged(caip2: Caip2): void;
+  addressChanged(data: AddressChangedEventData): void;
+  error(error: WalletErrorState): void;
+  private resolveAddresses;
+}
+//#endregion
+//#region src/core/connectors/base-connector.d.ts
+declare abstract class BaseConnector<W extends WalletType, TClient, TProvider extends Provider<W> = Provider<W>> implements Connector<W, TClient, TProvider> {
+  readonly walletType: W;
+  protected readonly events: ConnectorEventEmitter;
+  protected readonly store: WalletStore;
+  protected readonly config: ConnectorConfig<W>;
+  protected readonly resolvedConfig: ResolvedWalletConfig;
+  private initPromise;
+  private initResolved;
+  constructor(store: WalletStore, config: ConnectorConfig<W>);
+  get initialized(): boolean;
+  initialize(): Promise<void>;
+  /**
+   * Reset init state so next operation re-initializes the SDK.
+   * Required for MetaMask/Xaman (SDK terminates on disconnect).
+   * WalletConnect should NOT call this — its provider survives disconnect.
+   */
+  protected resetInitialization(): void;
+  protected abstract onInitialize(): Promise<void>;
+  protected emitError(error: unknown): void;
+  private wrapAsync;
+  abstract connect(...args: never[]): Promise<void>;
+  abstract disconnect(): Promise<void>;
+  abstract restoreConnection(): Promise<void>;
+  abstract switchChain(caip2: SupportedWalletChains<W>[number]): Promise<void>;
+  abstract getClient(): TClient;
+  abstract getProvider(): TProvider;
+}
+//#endregion
+//#region src/core/clients/xrp/xrp-client.d.ts
+interface XrpClient extends ChainClient {
+  sendTx: (tx: SubmittableTransaction) => Promise<string>;
+}
+//#endregion
+//#region src/core/connectors/dcent/dcent-xrpl-client.d.ts
+declare class DcentXrpClient implements XrpClient {
+  private readonly provider;
+  private readonly resolvedConfig;
+  constructor(provider: DcentXrplProvider, resolvedConfig: ResolvedWalletConfig);
+  sendTx(tx: SubmittableTransaction): Promise<string>;
+  getBalance(address: string): Promise<number>;
+  getCaip2(): Promise<XRPlCaip2>;
+  onDestroy(): Promise<void>;
+}
+//#endregion
+//#region src/core/connectors/dcent/dcent-connector.d.ts
+type DcentProvider$1 = DcentXrplProvider;
+declare class DcentConnector extends BaseConnector<"dcent", DcentXrpClient, DcentProvider$1> {
+  private client;
+  private provider;
+  constructor(store: WalletStore, config: ConnectorConfig<"dcent">);
+  static isAvailable(): boolean;
+  static getDynamicLink(targetUrl: string, caip2: XRPlCaip2): string;
+  protected onInitialize(): Promise<void>;
+  connect(_chains?: SupportedWalletChains<"dcent">): Promise<void>;
+  disconnect(): Promise<void>;
+  restoreConnection(): Promise<void>;
+  switchChain(caip2: SupportedWalletChains<"dcent">[number]): Promise<void>;
+  getClient(): DcentXrpClient;
+  getProvider(): DcentProvider$1;
+  private get connectionState();
+}
+//#endregion
+//#region src/core/connectors/ledger/clients/ledger-evm-client.d.ts
+declare class LedgerEvmClient extends EvmClient implements LedgerClient {
+  private readonly _app;
+  constructor(chain: EvmChain, publicClient: PublicClient, walletClient: WalletClient, app: LedgerApp);
+  static createForLedger(args: CreateLedgerClientArgs, chain: EvmChain, account: Account): LedgerEvmClient;
+  getLedgerApp(): LedgerApp;
+}
+//#endregion
+//#region src/core/connectors/ledger/apps/xrp/xrp-ledger-app.d.ts
+declare class XrpLedgerApp extends Xrp implements LedgerApp {
+  getComputedAddress(bip44: Bip44, _hrp?: string): Promise<LedgerComputedAddress>;
+  getComputedAddresses(bip44s: Array<Bip44>, hrp?: string): Promise<Array<LedgerComputedAddress>>;
+}
+//#endregion
+//#region src/core/clients/xrp/base-xrpl-client.d.ts
+declare class BaseXrplClient extends Client {
+  onDestroy(): Promise<void>;
+  ensureConnected(): Promise<void>;
+  getBalance(address: string): Promise<number>;
+}
+//#endregion
+//#region src/core/clients/xrp/xrpl-client.d.ts
+declare class XrplClient extends BaseXrplClient {
+  private readonly chain;
+  constructor(chain: XrplChain);
+  getCaip2(): Promise<XRPlCaip2>;
+  onDestroy(): Promise<void>;
+}
+//#endregion
+//#region src/core/connectors/ledger/clients/ledger-xrp-client.d.ts
+declare class LedgerXrpClient extends XrplClient implements LedgerClient<XrpLedgerApp>, XrpClient {
+  private readonly args;
+  constructor(chain: XrplChain, args: CreateLedgerClientArgs);
+  getLedgerApp(): XrpLedgerApp;
+  private getAddressInfo;
+  sendTx(tx: SubmittableTransaction): Promise<string>;
+}
+//#endregion
+//#region src/core/connectors/ledger/internal/ledger-session-manager.d.ts
+interface LedgerSession {
+  caip2: LedgerCaip2;
+  bip44: Bip44;
+  hdStandard: LedgerHDStandard;
+  account: LedgerComputedAddress;
+}
+//#endregion
+//#region src/core/connectors/ledger/ledger-connector.d.ts
+declare class LedgerConnector extends BaseConnector<"ledger", LedgerClient, LedgerProvider> {
+  private readonly transportManager;
+  private readonly sessionManager;
+  private readonly clientFactory;
+  private readonly mutex;
+  private client;
+  constructor(store: WalletStore, config: ConnectorConfig<"ledger">);
+  protected onInitialize(): Promise<void>;
+  connect(chain: LedgerCaip2, options?: LedgerConnectOptions): Promise<void>;
+  disconnect(): Promise<void>;
+  restoreConnection(): Promise<void>;
+  switchChain(chain: LedgerCaip2): Promise<void>;
+  getSession(): LedgerSession | null;
+  getClient(): LedgerClient;
+  getProvider(): LedgerProvider;
+  fetchAddressesForSelection(chain: LedgerCaip2, paths: Bip44[]): Promise<LedgerComputedAddress[]>;
+  private performConnect;
+  private performRestore;
+  private establishConnection;
+  private handleDisconnect;
+  private requireApp;
+}
+//#endregion
+//#region src/core/connectors/metamask/metamask-connector.d.ts
+declare class MetaMaskConnector extends BaseConnector<"metamask", EvmClient, MetaMaskProvider> {
+  private sdk;
+  private provider;
+  private client;
+  protected onInitialize(): Promise<void>;
+  connect(chain: SupportedWalletChains<"metamask">[number]): Promise<void>;
+  disconnect(): Promise<void>;
+  restoreConnection(): Promise<void>;
+  switchChain(caip2: Eip155Caip2): Promise<void>;
+  getClient(): EvmClient;
+  getProvider(): MetaMaskProvider;
+  private onAccountsChanged;
+  private onChainChanged;
+  private createClient;
+  private addChain;
+  private getConnectionState;
+  private getCurrentCaip2;
+}
+//#endregion
+//#region src/core/connectors/wallet-connect/clients/wallet-connect-xrpl-client.d.ts
+declare class WalletConnectXrpClient extends XrplClient implements XrpClient {
+  provider: UniversalProvider;
+  constructor(chain: XrplChain, provider: UniversalProvider);
+  sendTx(tx: SubmittableTransaction): Promise<string>;
+}
+//#endregion
+//#region src/core/connectors/wallet-connect/wallet-connect-connector.d.ts
+/**
+ * WalletConnect connector using Reown AppKit for QR modal.
+ *
+ * - connect() opens AppKit first (spinner), then provider.connect() emits display_uri
+ *   which auto-populates the QR in the modal. The empty display_uri handler is required.
+ * - disconnect() cleans up the WC session, but provider and AppKit survive —
+ *   no re-initialization needed (unlike MetaMask/Xaman).
+ * - Only EVM chains are registered with AppKit (ChainNamespace doesn't include "xrpl").
+ *   XRPL sessions still work fine without AppKit awareness.
+ */
+declare class WalletConnectConnector extends BaseConnector<"wallet-connect", ChainClient, WalletConnectProvider> {
+  protected readonly config: WalletConnectConnectorConfig;
+  private provider;
+  private sessionManager;
+  private clientFactory;
+  private appKit;
+  private client;
+  constructor(store: WalletStore, config: WalletConnectConnectorConfig);
+  protected onInitialize(): Promise<void>;
+  connect(chains?: SupportedWalletChains<"wallet-connect"> | readonly Caip2[]): Promise<void>;
+  disconnect(): Promise<void>;
+  restoreConnection(): Promise<void>;
+  switchChain(caip2: SupportedWalletChains<"wallet-connect">[number]): Promise<void>;
+  getClient(): ChainClient;
+  getProvider(): WalletConnectProvider;
+  private registerProviderEvents;
+  private registerModalCloseHandler;
+  private onSessionCreated;
+  private onConnectionFailed;
+  private onProposalExpire;
+  private onAccountsChanged;
+  private onChainChanged;
+  private onDisconnect;
+  private buildAppKitNetworks;
+  private buildCustomRpcUrls;
+  private get connectionState();
+  private get storedCaip2();
+}
+//#endregion
+//#region src/core/connectors/xaman/xaman-types.d.ts
+interface XamanConfig {
+  apiKey: string;
+}
+//#endregion
+//#region src/core/connectors/xaman/xaman-xrpl-client.d.ts
+declare class XamanClient extends Xumm implements XrpClient {
+  private static readonly NETWORK_KEYS;
+  private readonly resolvedConfig;
+  constructor(config: XamanConfig, resolvedConfig: ResolvedWalletConfig);
+  sendTx(tx: SubmittableTransaction): Promise<string>;
+  getCaip2(): Promise<XRPlCaip2>;
+  onDestroy(): Promise<void>;
+  getBalance(address: string): Promise<number>;
+  getSimpleClient(): Promise<XrplClient>;
+  toCaip2Network(networkId: number | string): XRPlCaip2;
+}
+//#endregion
+//#region src/core/connectors/xaman/xaman-connector.d.ts
+declare class XamanConnector extends BaseConnector<"xaman", XamanClient, XamanProvider> {
+  protected readonly config: XamanConnectorConfig;
+  private client;
+  constructor(store: WalletStore, config: XamanConnectorConfig);
+  protected onInitialize(): Promise<void>;
+  /**
+   * Xaman doesn't support session restoration — authorize() is fire-and-forget,
+   * with state changes arriving via SDK events (ready, success, error, logout).
+   */
+  restoreConnection(): Promise<void>;
+  connect(_chains?: SupportedWalletChains<"xaman"> | readonly Caip2[]): Promise<void>;
+  disconnect(): Promise<void>;
+  switchChain(_caip2: SupportedWalletChains<"xaman">[number]): Promise<void>;
+  getClient(): XamanClient;
+  getProvider(): XamanProvider;
+  private onReady;
+  private onSuccess;
+  private onError;
+  private onLogout;
+  private onNetworkSwitch;
+  private isLoggedIn;
+  private get connectionState();
+  private get storedCaip2();
+}
+//#endregion
+//#region src/core/connectors/connector-types.d.ts
+type MetaMaskProvider = EIP1193Provider;
+type WalletConnectProvider = UniversalProvider;
+type XamanProvider = Xumm;
+type LedgerProvider = "ledger-provider";
+type DcentProvider = DcentXrplProvider;
+interface ProviderMap {
+  metamask: MetaMaskProvider;
+  "wallet-connect": WalletConnectProvider;
+  ledger: LedgerProvider;
+  xaman: XamanProvider;
+  dcent: DcentProvider;
+}
+type Provider<W extends WalletType> = ProviderMap[W];
+interface ClientMap {
+  metamask: EvmClient;
+  "wallet-connect": EvmClient | WalletConnectXrpClient;
+  ledger: LedgerEvmClient | LedgerXrpClient;
+  xaman: XamanClient;
+  dcent: DcentXrpClient;
+}
+type Client$1<W extends WalletType> = ClientMap[W];
+interface Connector<W extends WalletType, TClient, TProvider = Provider<W>> {
+  readonly walletType: W;
+  initialize(): Promise<void>;
+  connect(...args: never[]): Promise<void>;
+  disconnect(): Promise<void>;
+  restoreConnection(): Promise<void>;
+  switchChain(caip2: SupportedWalletChains<W>[number]): Promise<void>;
+  getClient(): TClient;
+  getProvider(): TProvider;
+}
+interface ConnectorConfig<W extends WalletType = WalletType> {
+  walletType: W;
+  metadata: WalletMetadata;
+  resolvedConfig: ResolvedWalletConfig;
+}
+interface WalletConnectConnectorConfig extends ConnectorConfig<"wallet-connect"> {
+  projectId: string;
+}
+interface XamanConnectorConfig extends ConnectorConfig<"xaman"> {
+  apiKey: string;
+}
+type ConnectorTypeMap<W extends WalletType = WalletType> = Connector<W, Client$1<W>, Provider<W>>;
+/**
+ * Maps wallet types to their concrete connector classes.
+ * Use this when you need the full connector API with specific connect signatures.
+ */
+interface ConcreteConnectorMap {
+  metamask: MetaMaskConnector;
+  "wallet-connect": WalletConnectConnector;
+  ledger: LedgerConnector;
+  xaman: XamanConnector;
+  dcent: DcentConnector;
+}
+type ConcreteConnector<W extends WalletType> = ConcreteConnectorMap[W];
+type ConnectWalletArgs = {
+  wallet: "wallet-connect";
+  chains: SupportedWalletChains<"wallet-connect">;
+} | {
+  wallet: "metamask";
+  chain: Eip155Caip2;
+} | {
+  wallet: "ledger";
+  chain: LedgerCaip2;
+  options?: LedgerConnectOptions;
+} | {
+  wallet: "xaman";
+} | {
+  wallet: "dcent";
+};
+type ChainSelectionMode = "single" | "multi" | null;
+//#endregion
+//#region src/core/stores/wallet-store/aggregate-wallet-store.d.ts
+type AggregateWalletState<T extends WalletType = WalletType> = {
+  wallets: Record<T, WalletState>;
+};
+type AggregateWalletEvents = {
+  walletUpdated: {
+    walletType: WalletType;
+    context: WalletState;
+  };
+};
+declare const createAggregateWalletStore: <T extends WalletType>(stores: Map<T, WalletStore>) => _xstate_store0.Store<AggregateWalletState<T>, AggregateWalletEvents, never>;
+type AggregateWalletStore<T extends WalletType = WalletType> = ReturnType<typeof createAggregateWalletStore<T>>;
+//#endregion
+//#region src/core/config/config-resolver.d.ts
+declare class ConfigResolver {
+  private readonly globalOverrides;
+  private readonly walletOverrides;
+  private readonly walletOptions;
+  constructor(options: MultiChainOptions);
+  getWalletOptions<W extends WalletType>(walletType: W): WalletOptions | undefined;
+  resolveForWallet<W extends WalletType>(walletType: W): ResolvedWalletConfig<W>;
+  private resolveChain;
+  private static createResolvedConfig;
+}
+//#endregion
+//#region src/core/multichain/multichain.d.ts
+declare class MultiChain {
+  private readonly stores;
+  private readonly connectors;
+  private readonly aggregateStore;
+  private readonly configResolver;
+  private readonly events;
+  private subscriptions;
+  private mounted;
+  constructor(options: MultiChainOptions, inspector?: ReturnType<typeof createBrowserInspector>);
+  mount(): Promise<void>;
+  disconnect(walletType: WalletType): Promise<void>;
+  disconnectAll(): Promise<void>;
+  /**
+   * Connect a wallet with type-safe discriminated union arguments.
+   *
+   * Each wallet type has its own connection signature:
+   * - wallet-connect: { wallet: "wallet-connect", chains: [...] }
+   * - metamask: { wallet: "metamask", chain: "eip155:..." }
+   * - ledger: { wallet: "ledger", chain: "...", options?: {...} }
+   * - xaman: { wallet: "xaman" }
+   * - dcent: { wallet: "dcent" }
+   */
+  connect(args: ConnectWalletArgs): Promise<void>;
+  getAggregateStore(): AggregateWalletStore;
+  getWalletTypes(): WalletType[];
+  getConnector<W extends WalletType>(walletType: W): ConcreteConnector<W>;
+  onWalletEvent<K extends WalletEmittedEvent["type"]>(walletType: WalletType, eventType: K, callback: (event: WalletEmittedEvent & {
+    type: K;
+  }) => void): Subscription | undefined;
+  getConfigResolver(): ConfigResolver;
+  /** Check if any wallet is currently connected to a specific chain. */
+  isConnectedByCaip2(caip2: Caip2): boolean;
+  private registerGlobalListeners;
+  private registerAggregateSync;
+}
+//#endregion
+//#region src/core/chains/chain.utils.d.ts
+declare class ChainGuards {
+  static isRpcError(error: unknown): error is RpcError;
+  static isEvmCaip2(caip2: Caip2): caip2 is Eip155Caip2;
+  static isXrplCaip2(caip2: Caip2): caip2 is XRPlCaip2;
+  static isEvmChain(chain: BaseChain): chain is EvmChain;
+  static isXrplChain(chain: BaseChain): chain is BaseChain<NamespaceFilter<Caip2, "xrpl">>;
+  static isEvmNamespace: (namespace: Caip2Namespace) => namespace is "eip155";
+}
+//#endregion
+//#region src/core/errors/error-codes.d.ts
+/**
+ * Error codes for all connectors.
+ * Numbers as keys = duplicates impossible.
+ *
+ * Ranges:
+ * - 4000-4099: Common (all connectors)
+ * - 4100-4199: MetaMask
+ * - 4200-4299: Ledger
+ * - 4300-4399: WalletConnect
+ * - 4400-4499: Xaman
+ * - 4500-4599: D'CENT
+ */
+declare const errorCodeMap: {
+  readonly 4001: "COMMON_USER_REJECTED";
+  readonly 4002: "COMMON_NOT_CONNECTED";
+  readonly 4003: "COMMON_CHAIN_NOT_CONFIGURED";
+  readonly 4004: "COMMON_CHAIN_NOT_SUPPORTED";
+  readonly 4005: "COMMON_FEATURE_NOT_SUPPORTED";
+  readonly 4006: "COMMON_CONNECTION_FAILED";
+  readonly 4007: "COMMON_UNKNOWN_CHAIN_ID";
+  readonly 4008: "COMMON_NO_ACCOUNTS";
+  readonly 4009: "COMMON_PROVIDER_ERROR";
+  readonly 4010: "COMMON_CONNECTION_IN_PROGRESS";
+  readonly 4100: "METAMASK_PROVIDER_NOT_FOUND";
+  readonly 4101: "METAMASK_CHAIN_NOT_ADDED";
+  readonly 4102: "METAMASK_NOT_INSTALLED";
+  readonly 4200: "LEDGER_DEVICE_LOCKED";
+  readonly 4201: "LEDGER_APP_NOT_OPEN";
+  readonly 4202: "LEDGER_WRONG_APP";
+  readonly 4203: "LEDGER_TRANSPORT_ERROR";
+  readonly 4204: "LEDGER_CONNECTION_FAILED";
+  readonly 4205: "LEDGER_TX_REJECTED";
+  readonly 4300: "WALLET_CONNECT_SESSION_EXPIRED";
+  readonly 4301: "WALLET_CONNECT_PAIRING_FAILED";
+  readonly 4302: "WALLET_CONNECT_SESSION_NOT_FOUND";
+  readonly 4303: "WALLET_CONNECT_PROVIDER_NOT_INITIALIZED";
+  readonly 4400: "XAMAN_SIGN_REJECTED";
+  readonly 4401: "XAMAN_QR_TIMEOUT";
+  readonly 4402: "XAMAN_SDK_NOT_READY";
+  readonly 4403: "XAMAN_AUTHORIZATION_FAILED";
+  readonly 4500: "DCENT_NOT_IN_BROWSER";
+  readonly 4501: "DCENT_SIGN_REJECTED";
+};
+type ErrorCodeMap = typeof errorCodeMap;
+type CodeNumber = keyof ErrorCodeMap;
+type CodeName = ErrorCodeMap[CodeNumber];
+type ReverseErrorCodeMap = { readonly [K in CodeName]: CodeNumber };
+declare const ErrorCode: ReverseErrorCodeMap;
+type ErrorCodeKey = keyof typeof ErrorCode;
+type CommonCode = Extract<ErrorCodeKey, `COMMON_${string}`>;
+type MetaMaskCode = Extract<ErrorCodeKey, `METAMASK_${string}`>;
+type LedgerCode = Extract<ErrorCodeKey, `LEDGER_${string}`>;
+type WalletConnectCode = Extract<ErrorCodeKey, `WALLET_CONNECT_${string}`>;
+type XamanCode = Extract<ErrorCodeKey, `XAMAN_${string}`>;
+type DcentCode = Extract<ErrorCodeKey, `DCENT_${string}`>;
+type MetaMaskErrorCode = CommonCode | MetaMaskCode;
+type LedgerErrorCode = CommonCode | LedgerCode;
+type WalletConnectErrorCode = CommonCode | WalletConnectCode;
+type XamanErrorCode = CommonCode | XamanCode;
+type DcentErrorCode = CommonCode | DcentCode;
+//#endregion
+//#region src/core/errors/wallet-error.d.ts
+declare class WalletError extends Error {
+  readonly code: number;
+  readonly codeKey: ErrorCodeKey;
+  readonly walletType: WalletType;
+  readonly cause?: unknown;
+  constructor(walletType: WalletType, codeKey: ErrorCodeKey, cause?: unknown);
+}
+//#endregion
+//#region src/core/connectors/dcent/dcent-error.d.ts
+declare class DcentError extends WalletError {
+  readonly name = "DcentError";
+  constructor(code: DcentErrorCode, cause?: unknown);
+  static fromError(_error: unknown): DcentError | null;
+}
+//#endregion
+//#region src/core/connectors/ledger/ledger-error.d.ts
+declare class LedgerError extends WalletError {
+  readonly name = "LedgerError";
+  private static readonly TRANSPORT_MAPPINGS;
+  constructor(code: LedgerErrorCode, cause?: unknown);
+  /** Maps raw @ledgerhq transport errors to LedgerError. Returns null for unknown errors. */
+  static fromError(error: unknown): LedgerError | null;
+}
+//#endregion
+//#region src/core/connectors/metamask/metamask-error.d.ts
+declare class MetaMaskError extends WalletError {
+  readonly name = "MetaMaskError";
+  constructor(code: MetaMaskErrorCode, cause?: unknown);
+  static fromError(error: unknown): MetaMaskError | null;
+}
+//#endregion
+//#region src/core/connectors/wallet-connect/wallet-connect-error.d.ts
+declare class WalletConnectError extends WalletError {
+  readonly name = "WalletConnectError";
+  constructor(code: WalletConnectErrorCode, cause?: unknown);
+  static fromError(error: unknown): WalletConnectError | null;
+}
+//#endregion
+//#region src/core/connectors/xaman/xaman-error.d.ts
+declare class XamanError extends WalletError {
+  readonly name = "XamanError";
+  constructor(code: XamanErrorCode, cause?: unknown);
+  static fromError(_error: unknown): XamanError | null;
+}
+//#endregion
+//#region src/core/errors/wallet-error-helper.d.ts
+declare class WalletErrorHelper {
+  static isWalletError(error: unknown): error is WalletError;
+  static from(error: unknown, walletType: WalletType): WalletError | null;
+}
+//#endregion
+//#region src/core/utils/utils.d.ts
+/**
+ * Shortens an address for display (e.g., "0x1234...abcd").
+ * @param address - The full address string
+ * @param prefixLength - Number of characters to show at start (default: 6)
+ * @param suffixLength - Number of characters to show at end (default: 4)
+ */
+declare function shortenAddress(address: string, prefixLength?: number, suffixLength?: number): string;
+/** Type-safe `Object.keys()` that preserves key types. */
+declare function objectKeys<T extends object>(obj: T): Array<keyof T>;
+/** Type-safe `Object.values()` that preserves value types. */
+declare function objectValues<T extends object>(obj: T): Array<T[keyof T]>;
+/** Type-safe `Object.entries()` that preserves key and value types. */
+declare function objectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
+/** Type-safe `Object.fromEntries()` that preserves key and value types. */
+declare function objectFromEntries<K extends string, V>(entries: Array<[K, V]>): Record<K, V>;
+//#endregion
+export { ValidWalletsForChain as $, LedgerConnectOptions as A, ErrorEvent as B, LedgerSession as C, ChainClient as D, EvmClient as E, ChainChangedEvent as F, ResolvedWalletConfig as G, MetaMaskWalletOptions as H, ChainOverride as I, WalletOptions as J, WalletConnectWalletOptions as K, ConnectEvent as L, LedgerPaginatedBip44 as M, Bip44 as N, LedgerCaip2 as O, AccountChangedEvent as P, SupportedWalletChains as Q, DcentWalletOptions as R, ConnectorTypeMap as S, XrpClient as T, MultiChainEvents as U, LedgerWalletOptions as V, MultiChainOptions as W, WalletAddressState as X, XamanWalletOptions as Y, WalletState as Z, ConfigResolver as _, shortenAddress as a, EvmChain as at, ConnectWalletArgs as b, WalletConnectError as c, XrplChain as ct, DcentError as d, WalletType as et, WalletError as f, MultiChain as g, ChainGuards as h, objectValues as i, Eip155Caip2 as it, LedgerHDStandard as j, LedgerComputedAddress as k, MetaMaskError as l, ErrorCodeKey as m, objectFromEntries as n, Caip2 as nt, WalletErrorHelper as o, NonEvmChain as ot, ErrorCode as p, WalletMetadata as q, objectKeys as r, Chain as rt, XamanError as s, XRPlCaip2 as st, objectEntries as t, BaseChain as tt, LedgerError as u, ChainSelectionMode as v, DcentConnector as w, Connector as x, ConcreteConnector as y, DisconnectEvent as z };
+//# sourceMappingURL=utils-C64Z4fWz.d.mts.map