@babylonlabs-io/wallet-connector 0.4.0

package/LICENSE

@@ -0,0 +1,141 @@
+Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved. "Business Source License" is a trademark of
+MariaDB Corporation Ab.
+
+---
+
+Parameters
+
+Licensor: Babylon Labs Ltd.
+
+Licensed Work: @babylonlabs-io/wallet-connect The Licensed Work is (c) 2024 Babylon Labs Ltd.
+
+Additional Use Grant:
+
+In addition to the uses permitted under the non-production license below, we grant you a limited, non-exclusive,
+non-transferable, non-sublicensable, revocable license, limited as set forth below, to use the Licensed Work in this
+repository for production commercial uses built on or using and integrated with the Babylon Protocol, not including
+Competing Uses.
+
+Any use beyond the scope of this license, including uses that are not built on or using and integrated with the Babylon
+Protocol, or are Competing Uses, will terminate this license to you, automatically and without notice.
+
+This License applies separately and solely to the specific versions of the Licensed Work in the specified repository on
+or before the date of this License, and we may require a different license and different provisions for each subsequent
+version of the Licensed Work released by us.
+
+"Babylon Labs", "we", "our", or "us" means Babylon Labs Ltd.
+
+"Babylon Protocol" means the Bitcoin staking protocol as further described in the documentation here
+(https://docs.babylonlabs.io/docs/introduction/babylon-overview), as updated from time to time.
+
+"Competing Use" means any use of the Licensed Work in any product, software, protocol, network, application, or service
+that is made available to any party and that (i) substitutes for the use of the Babylon Protocol, (ii) offers the same
+or substantially similar functionality as the Babylon Protocol or (iii) is built on or uses a protocol with
+substantially similar functionality as the Babylon Protocol or otherwise facilitates the staking of bitcoin other than
+by utilizing the Babylon Protocol.
+
+The provisions in this License apply to each individual, entity, group, or association (each and collectively, "you" or
+"your") who uses the Licensed Work for production, and you agree to such provisions. Your production use of the Licensed
+Work is conditional on your agreement to this License. If you do not agree and consent to be bound to this License, do
+not so use the Software.
+
+If you do not fall within the limited scope of this license as described above or below, or are otherwise not in strict
+compliance with this License, then this production license does not extend to you and does not grant you any production
+use, including any copying, distributing, or making any derivative use of the Licensed Work for production purposes.
+
+Limited Scope of License. Your commercial production license to the Licensed Work under this License does not extend to
+any use:
+
+1.  unless you have legal capacity to consent and agree to be bound by this License;
+2.  unless you have the technical knowledge necessary or advisable to understand and evaluate the risks of using the
+    Licensed Work and the Babylon Protocol;
+3.  if you are a resident or agent of, or an entity organized, incorporated or doing business in, Afghanistan, Belarus,
+    Bosnia and Herzegovina, Burundi, Central African Republic, Crimea, Cuba, Democratic People's Republic of Korea,
+    Democratic Republic of the Congo, Donetsk or Luhansk Regions of Ukraine, Eritrea, Guinea, Guinea-Bissau, Haiti,
+    Iran, Iraq, Lebanon, Libya, Mali, Myanmar, Nicaragua, Russia, Somalia, South Sudan, Sudan, Syria, Venezuela, Yemen,
+    or Zimbabwe or any other country to which the United States, the United Kingdom, the European Union or any of its
+    member states or the United Nations or any of its member states (collectively, the "Major Jurisdictions") embargoes
+    goods or imposes sanctions (such embargoed or sanctioned territories, collectively, the "Restricted Territories");
+4.  if you are, or if you directly or indirectly own or control, from any person or entity that is listed on any
+    sanctions list or equivalent maintained by any of the Major Jurisdictions (collectively, "Sanctions Lists Persons");
+5.  to transact in or with any Restricted Territories or Sanctions List Persons;
+6.  if you are a U.S. Person as defined in 17 CFR § 230.902, or currently or ordinarily located or resident in (or
+    incorporated or organized in) the United States of America, Canada, or Australia (collectively, "Excluded
+    Jurisdictions"), or to transact in or with Excluded Jurisdictions;
+7.  to defraud, or otherwise materially mislead, any person;
+8.  in violation of applicable laws, rules or regulations in your relevant jurisdiction;
+9.  that circumvents any sanctions or export controls targeting you or the country or territory where you are located;
+    or
+10. in any activity that transmits, exchanges, or is otherwise supported by the direct or indirect proceeds of criminal
+    or fraudulent activity.
+
+Any production use of the Licensed Work by you confirms your agreement to the foregoing limitations, and your
+understanding and agreement that they are limitations and not restrictions.
+
+Change Date: 2027-03-15 (March 15th, 2027)
+
+Change License: Apache 2.0
+
+---
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative works, redistribute, and make non-production
+use of the Licensed Work. The Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly available distribution of a specific
+version of the Licensed Work under this License, whichever comes first, the Licensor hereby grants you rights under the
+terms of the Change License, and the rights granted in the paragraph above terminate.
+
+If your use of the Licensed Work does not comply with the requirements currently in effect as described in this License,
+you must purchase a commercial license from the Licensor, its affiliated entities, or authorized resellers, or you must
+refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works of the Licensed Work, are subject to this
+License. This License applies separately for each version of the Licensed Work and the Change Date may vary for each
+version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy of the Licensed Work. If you receive the
+Licensed Work in original or modified form from a third party, the terms and conditions set forth in this License apply
+to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically terminate your rights under this License
+for the current and all other versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of Licensor or its affiliates (provided that you may
+use a trademark or logo of Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS
+ALL WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.
+
+MariaDB hereby grants you permission to use this License’s text to license your works, and to refer to it using the
+trademark "Business Source License", as long as you comply with the Covenants of Licensor below.
+
+---
+
+Covenants of Licensor
+
+In consideration of the right to use this License’s text and the "Business Source License" name and trademark, Licensor
+covenants to MariaDB, and to all other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version, or a license that is compatible with GPL
+   Version 2.0 or a later version, where "compatible" means that software provided under the Change License can be
+   included in a program with software provided under GPL Version 2.0 or a later version. Licensor may specify
+   additional Change Licenses without limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not impose any additional restriction on the
+   right granted in this License, as the Additional Use Grant; or (b) insert the text "None".
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.
+
+---
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open Source license. However, the Licensed Work
+will eventually be made available under an Open Source License, as stated in this License.

package/README.md

@@ -0,0 +1,234 @@
+<p align="center">
+    <img
+        alt="Babylon Logo"
+        src="https://github.com/user-attachments/assets/dc74271e-90f1-44bd-9122-2b7438ab375c"
+        width="100"
+    />
+    <h3 align="center">@babylonlabs-io/wallet-connect</h3>
+    <p align="center">Babylon Wallet Connector</p>
+</p>
+<br/>
+
+- [Key Features](#key-features)
+- [Overview](#overview)
+- [Installation](#installation)
+- [Version Release](#version-release)
+  - [Stable version](#stable-version)
+- [Storybook](#storybook)
+- [Wallet Integration](#wallet-integration)
+  - [1. Browser extension wallets](#1-browser-extension-wallets)
+  - [2. Mobile wallets](#2-mobile-wallets)
+    - [IBTCProvider](#ibtcprovider)
+    - [IBBNProvider](#ibbnprovider)
+
+The Babylon Wallet Connector repository provides the wallet connection component
+used in the Babylon Staking Dashboard. This component enables the connection of
+both Bitcoin and Babylon chain wallets.
+
+## Key Features
+
+- Unified interfaces for Bitcoin and Babylon wallet connections
+- Support for browser extension wallets
+- Support for hardware wallets
+- Mobile wallet compatibility through injectable interfaces
+- Tomo Connect integration for broader wallet ecosystem
+
+## Overview
+
+The Babylon Wallet Connector provides a unified interface for integrating both
+Bitcoin and Babylon wallets into Babylon dApp. It supports both native wallet
+extensions and injectable mobile wallets.
+
+The main architectural difference is that native wallets are built into the
+library, while injectable wallets can be dynamically added by injecting their
+implementation into the webpage's `window` object before the dApp loads.
+
+## Installation
+
+```bash
+npm i @babylonlabs-io/wallet-connect
+```
+
+## Version Release
+
+### Stable version
+
+Stable release versions are manually released from the main branch.
+
+## Storybook
+
+```bash
+npm run dev
+```
+
+## Wallet Integration
+
+> ⚠️ **IMPORTANT**: Breaking changes to the wallet methods used by the Babylon
+> web application are likely to cause incompatibility with it or lead to
+> unexpected behavior with severe consequences.
+>
+> Please make sure to always maintain backwards compatibility and test
+> thoroughly all changes affecting the methods required by the Babylon web
+> application. If you are unsure about a change, please reach out to the Babylon
+> Labs team.
+
+This guide explains how to integrate wallets with the Babylon staking app. The
+dApp supports both Bitcoin and Babylon wallets through two integration paths:
+
+### 1. Browser extension wallets
+
+The recommended way to integrate your wallet with Babylon staking app is through
+[Tomo Connect SDK Lite](https://docs.tomo.inc/tomo-sdk/tomo-connect-sdk-lite).
+Please refer to Tomo's documentation for integration details.
+
+### 2. Mobile wallets
+
+Full interface definitions can be found in
+[src/core/types.ts](src/core/types.ts).
+
+Below we outline the interfaces for Bitcoin and Babylon wallets that need to be
+implemented for integration with the Babylon staking app.
+
+#### IBTCProvider
+
+```ts
+interface IBTCProvider extends IProvider {
+  /**
+   * Connects to the wallet and returns the instance of the wallet provider.
+   * Currently only supports "native segwit" and "taproot" address types.
+   * @returns A promise that resolves to an instance of the wrapper wallet provider in babylon friendly format.
+   * @throws An error if the wallet is not installed or if connection fails.
+   */
+  connectWallet(): Promise<void>;
+
+  /**
+   * Gets the address of the connected wallet.
+   * @returns A promise that resolves to the address of the connected wallet.
+   */
+  getAddress(): Promise<string>;
+
+  /**
+   * Gets the public key of the connected wallet.
+   * @returns A promise that resolves to the public key of the connected wallet.
+   */
+  getPublicKeyHex(): Promise<string>;
+
+  /**
+   * Signs the given PSBT in hex format.
+   * @param psbtHex - The hex string of the unsigned PSBT to sign.
+   * @returns A promise that resolves to the hex string of the signed PSBT.
+   */
+  signPsbt(psbtHex: string): Promise<string>;
+
+  /**
+   * Signs multiple PSBTs in hex format.
+   * @param psbtsHexes - The hex strings of the unsigned PSBTs to sign.
+   * @returns A promise that resolves to an array of hex strings, each representing a signed PSBT.
+   */
+  signPsbts(psbtsHexes: string[]): Promise<string[]>;
+
+  /**
+   * Gets the network of the current account.
+   * @returns A promise that resolves to the network of the current account.
+   */
+  getNetwork(): Promise<Network>;
+
+  /**
+   * Signs a message using the specified signing method.
+   * @param message - The message to sign.
+   * @param type - The signing method to use.
+   * @returns A promise that resolves to the signed message.
+   */
+  signMessage(message: string, type: "ecdsa"): Promise<string>;
+
+  /**
+   * Retrieves the inscriptions for the connected wallet.
+   * @returns A promise that resolves to an array of inscriptions.
+   */
+  getInscriptions(): Promise<InscriptionIdentifier[]>;
+
+  /**
+   * Registers an event listener for the specified event.
+   * At the moment, only the "accountChanged" event is supported.
+   * @param eventName - The name of the event to listen for.
+   * @param callBack - The callback function to be executed when the event occurs.
+   */
+  on(eventName: string, callBack: () => void): void;
+
+  /**
+   * Unregisters an event listener for the specified event.
+   * @param eventName - The name of the event to listen for.
+   * @param callBack - The callback function to be executed when the event occurs.
+   */
+  off(eventName: string, callBack: () => void): void;
+
+  /**
+   * Gets the name of the wallet provider.
+   * @returns A promise that resolves to the name of the wallet provider.
+   */
+  getWalletProviderName(): Promise<string>;
+
+  /**
+   * Gets the icon of the wallet provider.
+   * @returns A promise that resolves to the icon of the wallet provider.
+   */
+  getWalletProviderIcon(): Promise<string>;
+}
+```
+
+#### IBBNProvider
+
+```ts
+export interface IBBNProvider extends IProvider {
+  /**
+   * Connects to the wallet and returns the instance of the wallet provider.
+   * @returns A promise that resolves to an instance of the wrapper wallet provider.
+   * @throws An error if the wallet is not installed or if connection fails.
+   */
+  connectWallet(): Promise<void>;
+
+  /**
+   * Gets the address of the connected wallet.
+   * @returns A promise that resolves to the address of the connected wallet.
+   */
+  getAddress(): Promise<string>;
+
+  /**
+   * Gets the public key of the connected wallet.
+   * @returns A promise that resolves to the public key of the connected wallet.
+   */
+  getPublicKeyHex(): Promise<string>;
+
+  /**
+   * Gets the name of the wallet provider.
+   * @returns A promise that resolves to the name of the wallet provider.
+   */
+  getWalletProviderName(): Promise<string>;
+
+  /**
+   * Gets the icon of the wallet provider.
+   * @returns A promise that resolves to the icon of the wallet provider.
+   */
+  getWalletProviderIcon(): Promise<string>;
+
+  /**
+   * Retrieves an offline signer that supports both Amino and Direct signing methods.
+   * This signer is used for signing transactions offline before broadcasting them to the network.
+   *
+   * @returns {Promise<OfflineAminoSigner & OfflineDirectSigner>} A promise that resolves to a signer supporting both Amino and Direct signing
+   * @throws {Error} If wallet connection is not established or signer cannot be retrieved
+   */
+  getOfflineSigner(): Promise<OfflineAminoSigner & OfflineDirectSigner>;
+}
+```
+
+1. Implement provider interface
+2. Inject into `window` before loading dApp:
+
+```ts
+// For Bitcoin wallets
+window.btcwallet = new BTCWalletImplementation();
+
+// For Babylon wallets
+window.bbnwallet = new BBNWalletImplementation();
+```

package/dist/components/ChainButton/index.d.ts

@@ -0,0 +1,11 @@
+import { JSX, PropsWithChildren } from 'react';
+interface ChainButtonProps extends PropsWithChildren {
+    className?: string;
+    disabled?: boolean;
+    logo?: string | JSX.Element;
+    title?: string | JSX.Element;
+    alt?: string;
+    onClick?: () => void;
+}
+export declare function ChainButton({ className, disabled, alt, logo, title, children, onClick }: ChainButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Chains/container.d.ts

@@ -0,0 +1,8 @@
+interface ContainerProps {
+    className?: string;
+    onClose?: () => void;
+    onConfirm?: () => void;
+    onDisconnectWallet?: (chainId: string) => void;
+}
+export declare function ChainsContainer(props: ContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Chains/index.d.ts

@@ -0,0 +1,13 @@
+import { IChain, IWallet } from '../../core/types';
+interface ChainsProps {
+    disabled?: boolean;
+    chains: IChain[];
+    className?: string;
+    selectedWallets?: Record<string, IWallet | undefined>;
+    onClose?: () => void;
+    onConfirm?: () => void;
+    onDisconnectWallet?: (chainId: string) => void;
+    onSelectChain?: (chain: IChain) => void;
+}
+export declare const Chains: import('react').MemoExoticComponent<({ disabled, chains, selectedWallets, className, onClose, onConfirm, onSelectChain, onDisconnectWallet, }: ChainsProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/Chains/index.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Chains } from './index';
+declare const meta: Meta<typeof Chains>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Default: Story;

package/dist/components/ConnectedWallet/index.d.ts

@@ -0,0 +1,10 @@
+interface ConnectedWalletProps {
+    className?: string;
+    chainId: string;
+    logo: string;
+    name: string;
+    address: string;
+    onDisconnect?: (chainId: string) => void;
+}
+export declare const ConnectedWallet: import('react').MemoExoticComponent<({ className, chainId, logo, name, address, onDisconnect }: ConnectedWalletProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/Error/container.d.ts

@@ -0,0 +1,5 @@
+interface ErrorContainer {
+    className?: string;
+}
+export declare function ErrorContainer({ className }: ErrorContainer): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Error/index.d.ts

@@ -0,0 +1,12 @@
+interface ErrorProps {
+    className?: string;
+    icon?: JSX.Element;
+    title: string | JSX.Element;
+    description: string | JSX.Element;
+    cancelButton?: string | JSX.Element;
+    submitButton?: string | JSX.Element;
+    onCancel?: () => void;
+    onSubmit?: () => void;
+}
+export declare function Error({ className, icon, title, description, cancelButton, submitButton, onCancel, onSubmit, }: ErrorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/FieldControl/index.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+interface FieldControl {
+    label: string | JSX.Element;
+    className?: string;
+}
+export declare function FieldControl({ label, className, children }: PropsWithChildren<FieldControl>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Inscriptions/container.d.ts

@@ -0,0 +1,6 @@
+interface InscriptionsContainerProps {
+    className?: string;
+    onSubmit?: (value: boolean, showAgain: boolean) => void;
+}
+export declare function InscriptionsContainer({ className, onSubmit }: InscriptionsContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Inscriptions/index.d.ts

@@ -0,0 +1,7 @@
+import { BTCConfig } from '../../core/types';
+export interface Props {
+    className?: string;
+    onSubmit?: (value: boolean, showAgain: boolean) => void;
+    config?: BTCConfig;
+}
+export declare function Inscriptions({ className, config, onSubmit }: Props): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Loader/index.d.ts

@@ -0,0 +1,6 @@
+interface LoaderProps {
+    className?: string;
+    title?: string;
+}
+export declare function LoaderScreen({ className, title }: LoaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ResponsiveDialog/ResponsiveDialog.d.ts

@@ -0,0 +1,2 @@
+import { DialogProps } from '@babylonlabs-io/core-ui';
+export declare function ResponsiveDialog(props: DialogProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/TermsOfService/container.d.ts

@@ -0,0 +1,6 @@
+export interface TermsOfServiceContainerProps {
+    className?: string;
+    onClose?: () => void;
+    onSubmit?: () => void;
+}
+export declare function TermsOfServiceContainer(props: TermsOfServiceContainerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/TermsOfService/index.d.ts

@@ -0,0 +1,8 @@
+import { BTCConfig } from '../../core/types';
+export interface Props {
+    className?: string;
+    config?: BTCConfig;
+    onClose?: () => void;
+    onSubmit?: () => void;
+}
+export declare function TermsOfService({ className, onClose, onSubmit }: Props): import("react/jsx-runtime").JSX.Element;

package/dist/components/WalletButton/index.d.ts

@@ -0,0 +1,12 @@
+interface WalletButtonProps {
+    className?: string;
+    logo: string;
+    disabled?: boolean;
+    name: string;
+    label?: string;
+    fallbackLink?: string;
+    installed?: boolean;
+    onClick?: () => void;
+}
+export declare function WalletButton({ className, disabled, name, logo, label, fallbackLink, installed, onClick, }: WalletButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/WalletProvider/components/Screen.d.ts

@@ -0,0 +1,17 @@
+import { JSX } from 'react';
+import { Screen } from '../../../context/State.context';
+import { IChain, IWallet } from '../../../core/types';
+interface ScreenProps {
+    className?: string;
+    current: Screen;
+    lockInscriptions?: boolean;
+    widgets?: Record<string, JSX.Element | undefined>;
+    onSelectWallet?: (chain: IChain, wallet: IWallet) => void;
+    onDisconnectWallet?: (chainId: string) => void;
+    onAccepTermsOfService?: () => void;
+    onToggleInscriptions?: (value: boolean, showAgain: boolean) => void;
+    onClose?: () => void;
+    onConfirm?: () => void;
+}
+export declare function Screen(props: ScreenProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/WalletProvider/components/WalletDialog.d.ts

@@ -0,0 +1,6 @@
+interface WalletDialogProps {
+    onError?: (e: Error) => void;
+    config: any;
+}
+export declare function WalletDialog({ config, onError }: WalletDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/WalletProvider/constants.d.ts

@@ -0,0 +1,2 @@
+import { ChainConfigArr } from '../../context/Chain.context';
+export declare const config: ChainConfigArr;

package/dist/components/WalletProvider/index.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren } from 'react';
+import { ChainConfigArr } from '../../context/Chain.context';
+interface WalletProviderProps {
+    context?: any;
+    config: Readonly<ChainConfigArr>;
+    onError?: (e: Error) => void;
+}
+export declare function WalletProvider({ children, config, context, onError, }: PropsWithChildren<WalletProviderProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/WalletProvider/tesnet.d.ts

@@ -0,0 +1,4 @@
+import { ChainInfo } from '@keplr-wallet/types';
+export declare const BBN_TESTNET_RPC_URL = "https://rpc-dapp.testnet.babylonlabs.io/";
+export declare const BBN_TESTNET_LCD_URL = "https://lcd-dapp.testnet.babylonlabs.io/";
+export declare const bbnTestnet: ChainInfo;

package/dist/components/Wallets/container.d.ts

@@ -0,0 +1,11 @@
+import { JSX } from 'react';
+import { IChain, IWallet } from '../../core/types';
+interface WalletContainerProps {
+    widgets?: Record<string, JSX.Element | undefined>;
+    className?: string;
+    onClose?: () => void;
+    append?: JSX.Element;
+    onSelectWallet?: (chain: IChain, wallet: IWallet) => void;
+}
+export declare function WalletsContainer({ widgets, ...props }: WalletContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Wallets/index.d.ts

@@ -0,0 +1,10 @@
+import { IChain, IWallet } from '../../core/types';
+export interface WalletsProps {
+    chain: IChain;
+    className?: string;
+    append?: JSX.Element;
+    onClose?: () => void;
+    onSelectWallet?: (chain: IChain, wallet: IWallet) => void;
+    onBack?: () => void;
+}
+export declare const Wallets: import('react').MemoExoticComponent<({ chain, className, append, onClose, onBack, onSelectWallet }: WalletsProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/context/Chain.context.d.ts

@@ -0,0 +1,24 @@
+import { PropsWithChildren } from 'react';
+import { WalletConnector } from '../core/WalletConnector';
+import { BBNConfig, BTCConfig, ExternalConnector, IBBNProvider, IBTCProvider, IProvider } from '../core/types';
+interface ChainConfig<K extends string = string, P extends IProvider = IProvider, C = any> {
+    chain: K;
+    name?: string;
+    icon?: string;
+    config: C;
+    connectors?: ExternalConnector<P>[];
+}
+export type ChainConfigArr = (ChainConfig<"BTC", IBTCProvider, BTCConfig> | ChainConfig<"BBN", IBBNProvider, BBNConfig>)[];
+interface ProviderProps {
+    context: any;
+    config: Readonly<ChainConfigArr>;
+    onError?: (e: Error) => void;
+}
+export interface Connectors {
+    BTC: WalletConnector<"BTC", IBTCProvider, BTCConfig> | null;
+    BBN: WalletConnector<"BBN", IBBNProvider, BBNConfig> | null;
+}
+export declare const Context: import('react').Context<Connectors>;
+export declare function ChainProvider({ children, context, config, onError }: PropsWithChildren<ProviderProps>): import("react/jsx-runtime").JSX.Element;
+export declare const useChainProviders: () => Connectors;
+export {};

package/dist/context/Inscriptions.context.d.ts

@@ -0,0 +1,12 @@
+import { PropsWithChildren } from 'react';
+interface InscriptionContext {
+    lockInscriptions: boolean;
+    showAgain: boolean;
+    toggleLockInscriptions?: (value: boolean) => void;
+    toggleShowAgain?: (value: boolean) => void;
+}
+export declare function InscriptionProvider({ children, context }: PropsWithChildren<{
+    context: any;
+}>): import("react/jsx-runtime").JSX.Element;
+export declare const useInscriptionProvider: () => InscriptionContext;
+export {};