@ledgerhq/connect-kit 1.1.0-beta.0 → 1.1.0-beta.1

package/dist/umd/lib/errors.d.ts

@@ -5,12 +5,14 @@ export declare class ProviderTypeIsNotSupportedError extends Error {
     constructor();
 }
 export declare class ProviderRpcError extends Error {
-    code: any;
-    constructor(code: any, message: string);
+    readonly code: number;
+    constructor(code: number, message: string);
     toString(): string;
 }
 export declare class UserRejectedRequestError extends Error {
-    name: string;
     readonly code: number;
     constructor();
 }
+export declare class NoServerSideError extends Error {
+    constructor();
+}

package/dist/umd/lib/modal.d.ts

@@ -1,5 +1,15 @@
-import { ConnectWithLedgerLiveModalProps } from "../components/ConnectWithLedgerLiveModal/ConnectWithLedgerLiveModal";
-import { ExtensionUnavailableModalProps } from "../components/ExtensionUnavailableModal/ExtensionUnavailableModal";
-type ModalType = 'ConnectWithLedgerLiveModal' | 'PlatformNotSupportedModal' | 'ExtensionUnavailableModal';
-export declare function showModal(modalType: ModalType, props?: ExtensionUnavailableModalProps | ConnectWithLedgerLiveModalProps): void;
+import { UseLedgerLiveModalProps } from "../components/UseLedgerLiveModal/UseLedgerLiveModal";
+import { ExtensionInstallModalProps } from "../components/ExtensionInstallModal/ExtensionInstallModal";
+type ModalType = 'UseLedgerLiveModal' | 'PlatformNotSupportedModal' | 'ExtensionInstallModal';
+/**
+ * Shows a modal component.
+ */
+export declare function showModal(modalType: ModalType, props?: ExtensionInstallModalProps | UseLedgerLiveModalProps): void;
+/**
+ * Shows one of two modals depending on if the extension is supported or not.
+ */
+export declare function showExtensionOrLLModal(props: {
+    uri: string;
+    onClose: Function;
+}): void;
 export {};

package/dist/umd/lib/provider.d.ts

@@ -1,10 +1,8 @@
-import { EthereumProvider } from "../providers/Ethereum";
-import { SolanaProvider } from "../providers/Solana";
-export declare enum ConnectSupportedChains {
-    EthereumMainnet = 1,
-    Polygon = 137
-}
-export declare function isChainIdSupported(chainId: number): boolean;
+import { EthereumProvider } from "../providers/ExtensionEvm";
+import { SolanaProvider } from "../providers/ExtensionSolana";
+export declare const DEFAULT_CHAIN_ID: number;
+export declare const DEFAULT_REQUIRED_CHAINS: number[];
+export declare const DEFAULT_WALLETCONNECT_VERSION: number;
 export declare enum SupportedProviders {
     Ethereum = "Ethereum",
     Solana = "Solana"
@@ -14,6 +12,11 @@ export declare enum SupportedProviderImplementations {
     WalletConnect = "WalletConnect"
 }
 export type ProviderResult = EthereumProvider | SolanaProvider;
-export declare function setProviderType(providerType: SupportedProviders): void;
+/**
+ * Sets the provider implementation to be used by getProvider.
+ */
 export declare function setProviderImplementation(providerImplementation: SupportedProviderImplementations): void;
+/**
+ * Gets a provider instance based on the implementation set earlier.
+ */
 export declare function getProvider(): Promise<ProviderResult>;

package/dist/umd/lib/support.d.ts

@@ -1,20 +1,16 @@
-import { ConnectSupportedChains, SupportedProviders, SupportedProviderImplementations } from "./provider";
-export type CheckSupportOptions = {
-    providerType: SupportedProviders;
-    chainId?: number;
-    bridge?: string;
-    infuraId?: string;
-    rpc?: {
-        [chainId: number]: string;
-    };
-};
+import { SupportedProviderImplementations } from "./provider";
+import { CheckSupportOptions } from "./supportOptions";
 export type CheckSupportResult = {
     isLedgerConnectSupported?: boolean;
     isLedgerConnectEnabled?: boolean;
     isChainIdSupported?: boolean;
     providerImplementation: SupportedProviderImplementations;
 };
+/**
+ * Check support for user's platform.
+ */
 export declare function checkSupport(options: CheckSupportOptions): CheckSupportResult;
-export type CheckEthereumSupportOptions = CheckSupportOptions & {
-    chainId: ConnectSupportedChains;
-};
+/**
+ * Gets support results.
+ */
+export declare function getSupportResult(): CheckSupportResult;

package/dist/umd/lib/supportOptions.d.ts

@@ -0,0 +1,40 @@
+import type { CoreTypes } from '@walletconnect/types';
+import { WalletConnectProviderOptions } from "../providers/WalletConnectEvm";
+import { WalletConnectLegacyProviderOptions } from '../providers/WalletConnectLegacy';
+import { SupportedProviders } from "./provider";
+type CheckSupportCommonOptions = {
+    version?: number;
+    providerType: SupportedProviders;
+};
+export type CheckSupportWalletConnectProviderOptions = {
+    projectId?: string;
+    chains?: number[];
+    optionalChains?: number[];
+    methods?: string[];
+    optionalMethods?: string[];
+    events?: string[];
+    optionalEvents?: string[];
+    rpcMap?: {
+        [chainId: string]: string;
+    };
+    metadata?: CoreTypes.Metadata;
+};
+export type CheckSupportWalletConnectLegacyProviderOptions = {
+    chainId?: number;
+    bridge?: string;
+    infuraId?: string;
+    rpc?: {
+        [chainId: number]: string;
+    };
+};
+export type CheckSupportOptions = CheckSupportCommonOptions & CheckSupportWalletConnectProviderOptions & CheckSupportWalletConnectLegacyProviderOptions;
+export type ValidatedSupportOptions = CheckSupportOptions & WalletConnectProviderOptions & WalletConnectLegacyProviderOptions;
+/**
+ * Sets defaults and makes the result available for other modules.
+ */
+export declare const setSupportOptions: (options: CheckSupportOptions) => void;
+/**
+ * Gets the validated support options.
+ */
+export declare const getSupportOptions: () => ValidatedSupportOptions;
+export {};

package/dist/umd/providers/ExtensionEvm.d.ts

@@ -0,0 +1,46 @@
+import { Device } from "../lib/browser";
+export declare const EXTENSION_EVM_GLOBAL = "ethereum";
+export declare const EXTENSION_EVM_PROP = "isLedgerConnect";
+export declare enum ExtensionSupportedChains {
+    EthereumMainnet = 1,
+    Polygon = 137
+}
+/**
+ * Checks if the user's platform supports the extension.
+ */
+export declare function isExtensionSupported(device: Device): boolean;
+/**
+ * Checks if the chain id is supported by the extension.
+ */
+export declare function isChainIdSupported(chainId: number): boolean;
+/**
+ * Checks if all the chain ids are supported by the extension.
+ */
+export declare function areAllRequiredChainsSupported(chains: number[]): boolean;
+export type EthereumRequestPayload = {
+    method: string;
+    params?: unknown[] | Record<string, unknown> | undefined;
+};
+/**
+ * A common interface for all the returned providers.
+ */
+export interface EthereumProvider {
+    providers?: EthereumProvider[];
+    connector?: unknown;
+    session?: unknown;
+    request<T = unknown>(args: EthereumRequestPayload): Promise<T>;
+    disconnect?: {
+        (): Promise<void>;
+    };
+    on(event: any, listener: any): void;
+    removeListener(event: string, listener: any): void;
+}
+export interface ExtensionEvmProvider extends EthereumProvider {
+    [EXTENSION_EVM_PROP]: boolean;
+    chainId: string;
+}
+/**
+ * Gets the extension provider. In case it does not exist returns an instance
+ * of the install provider.
+ */
+export declare function getExtensionProvider(): EthereumProvider;

package/dist/umd/providers/{Solana.d.ts → ExtensionSolana.d.ts}

@@ -1,12 +1,15 @@
 import { ProviderResult } from "../lib/provider";
-export declare const LEDGER_SOLANA_PROVIDER = "solana";
-export declare const LEDGER_CONNECT_SOLANA_PROP = "isLedgerConnect";
+export declare const EXTENSION_SOLANA_PROVIDER = "solana";
+export declare const EXTENSION_SOLANA_PROP = "isLedgerConnect";
 export interface SolanaProvider {
-    [LEDGER_CONNECT_SOLANA_PROP]: boolean;
+    [EXTENSION_SOLANA_PROP]: boolean;
     signTransaction(...args: unknown[]): Promise<unknown>;
     signAllTransactions(...args: unknown[]): Promise<unknown>;
     signAndSendTransaction(...args: unknown[]): Promise<unknown>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
 }
+/**
+ * Gets the Solana provider.
+ */
 export declare function getSolanaProvider(): ProviderResult;

package/dist/umd/providers/WalletConnectEvm.d.ts

@@ -0,0 +1,13 @@
+import { default as WalletConnectProvider } from '../support/EthereumProvider/EthereumProvider';
+import { CheckSupportWalletConnectProviderOptions } from '../lib/supportOptions';
+/**
+ * Specifies the required options for the provider.
+ */
+export type WalletConnectProviderOptions = CheckSupportWalletConnectProviderOptions & {
+    projectId: string;
+    chains: number[];
+};
+/**
+ * Gets the WalletConnect provider.
+ */
+export declare function getWalletConnectProvider(): Promise<WalletConnectProvider>;

package/dist/umd/providers/WalletConnectLegacy.d.ts

@@ -0,0 +1,7 @@
+import { EthereumProvider } from './ExtensionEvm';
+import { CheckSupportWalletConnectLegacyProviderOptions } from '../lib/supportOptions';
+export type WalletConnectLegacyProviderOptions = CheckSupportWalletConnectLegacyProviderOptions;
+/**
+ * Gets the legacy WalletConnect provider.
+ */
+export declare function getWalletConnectLegacyProvider(): Promise<EthereumProvider>;

package/dist/umd/support/EthereumProvider/EthereumProvider.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { IEthereumProvider as IProvider, IEthereumProviderEvents, ProviderAccounts, RequestArguments } from "./types";
+import { Metadata, Namespace, UniversalProvider } from "@walletconnect/universal-provider/dist/index.umd.js";
+export type RpcEvent = "accountsChanged" | "chainChanged" | "message" | "disconnect" | "connect";
+export interface EthereumRpcMap {
+    [chainId: string]: string;
+}
+export interface SessionEvent {
+    event: {
+        name: string;
+        data: any;
+    };
+    chainId: string;
+}
+export interface EthereumRpcConfig {
+    chains: string[];
+    optionalChains?: string[];
+    methods: string[];
+    optionalMethods?: string[];
+    /**
+     * @description Events that the wallet MUST support or the connection will be rejected
+     */
+    events: string[];
+    optionalEvents?: string[];
+    rpcMap: EthereumRpcMap;
+    projectId: string;
+    metadata?: Metadata;
+}
+export interface ConnectOps {
+    chains?: number[];
+    optionalChains?: number[];
+    rpcMap?: EthereumRpcMap;
+    pairingTopic?: string;
+}
+export interface IEthereumProvider extends IProvider {
+    connect(opts?: ConnectOps | undefined): Promise<void>;
+}
+export declare function getRpcUrl(chainId: string, rpc: EthereumRpcConfig): string | undefined;
+export declare function getEthereumChainId(chains: string[]): number;
+export declare function toHexChainId(chainId: number): string;
+export type NamespacesParams = {
+    chains: EthereumRpcConfig["chains"];
+    optionalChains?: EthereumRpcConfig["optionalChains"];
+    methods?: EthereumRpcConfig["methods"];
+    optionalMethods?: EthereumRpcConfig["methods"];
+    events?: EthereumRpcConfig["events"];
+    rpcMap: EthereumRpcConfig["rpcMap"];
+    optionalEvents?: EthereumRpcConfig["events"];
+};
+export declare function buildNamespaces(params: NamespacesParams): {
+    required: Namespace;
+    optional?: Namespace;
+};
+export interface EthereumProviderOptions {
+    projectId: string;
+    /**
+     * @note Chains that your app intents to use and the peer MUST support. If the peer does not support these chains, the connection will be rejected.
+     * @default [1]
+     * @example [1, 3, 4, 5, 42]
+     */
+    chains: number[];
+    /**
+     * @note Optional chains that your app MAY attempt to use and the peer MAY support. If the peer does not support these chains, the connection will still be established.
+     * @default [1]
+     * @example [1, 3, 4, 5, 42]
+     */
+    optionalChains?: number[];
+    /**
+     * @note Methods that your app intents to use and the peer MUST support. If the peer does not support these methods, the connection will be rejected.
+     * @default ["eth_sendTransaction", "personal_sign"]
+     */
+    methods?: string[];
+    /**
+     * @note Methods that your app MAY attempt to use and the peer MAY support. If the peer does not support these methods, the connection will still be established.
+     */
+    optionalMethods?: string[];
+    events?: string[];
+    optionalEvents?: string[];
+    rpcMap?: EthereumRpcMap;
+    metadata?: Metadata;
+}
+export declare class EthereumProvider implements IEthereumProvider {
+    events: EventEmitter;
+    namespace: string;
+    accounts: string[];
+    signer: InstanceType<typeof UniversalProvider>;
+    chainId: number;
+    private rpc;
+    private readonly STORAGE_KEY;
+    constructor();
+    static init(opts: EthereumProviderOptions): Promise<EthereumProvider>;
+    request<T = unknown>(args: RequestArguments): Promise<T>;
+    sendAsync(args: RequestArguments, callback: (error: Error | null, response: any) => void): void;
+    get connected(): boolean;
+    get connecting(): boolean;
+    enable(): Promise<ProviderAccounts>;
+    connect(opts?: ConnectOps): Promise<void>;
+    disconnect(): Promise<void>;
+    on: IEthereumProviderEvents["on"];
+    once: IEthereumProviderEvents["once"];
+    removeListener: IEthereumProviderEvents["removeListener"];
+    off: IEthereumProviderEvents["off"];
+    get isWalletConnect(): boolean;
+    get session(): any;
+    private registerEventListeners;
+    private setHttpProvider;
+    private isCompatibleChainId;
+    private formatChainId;
+    private parseChainId;
+    private setChainIds;
+    private setChainId;
+    private parseAccountId;
+    private setAccounts;
+    private getRpcConfig;
+    private buildRpcMap;
+    private initialize;
+    private loadConnectOpts;
+    private getRpcUrl;
+    private loadPersistedSession;
+    private reset;
+    private persist;
+    private parseAccounts;
+    private parseAccount;
+}
+export default EthereumProvider;

package/dist/umd/support/EthereumProvider/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./values";
+export * from "./rpc";

package/dist/umd/support/EthereumProvider/constants/rpc.d.ts

@@ -0,0 +1,4 @@
+export declare const REQUIRED_METHODS: string[];
+export declare const OPTIONAL_METHODS: string[];
+export declare const REQUIRED_EVENTS: string[];
+export declare const OPTIONAL_EVENTS: string[];

package/dist/umd/support/EthereumProvider/constants/values.d.ts

@@ -0,0 +1,5 @@
+export declare const PROTOCOL = "wc";
+export declare const WC_VERSION = 2;
+export declare const CONTEXT = "ethereum_provider";
+export declare const STORAGE_KEY: string;
+export declare const RPC_URL = "https://rpc.walletconnect.com/v1/";

package/dist/umd/support/EthereumProvider/types.d.ts

@@ -0,0 +1,57 @@
+import { SignClientTypes } from "@walletconnect/types";
+import { EthereumProvider } from "./EthereumProvider";
+export interface ProviderRpcError extends Error {
+    message: string;
+    code: number;
+    data?: unknown;
+}
+export interface ProviderMessage {
+    type: string;
+    data: unknown;
+}
+export interface ProviderInfo {
+    chainId: string;
+}
+export interface RequestArguments {
+    method: string;
+    params?: unknown[] | object;
+}
+export type ProviderChainId = ProviderInfo["chainId"];
+export type ProviderAccounts = string[];
+export interface EIP1102Request extends RequestArguments {
+    method: "eth_requestAccounts";
+}
+export declare namespace IProviderEvents {
+    type Event = "connect" | "disconnect" | "message" | "chainChanged" | "accountsChanged" | "session_delete" | "session_event" | "session_update" | "display_uri";
+    interface EventArguments {
+        connect: ProviderInfo;
+        disconnect: ProviderRpcError;
+        message: ProviderMessage;
+        chainChanged: ProviderChainId;
+        accountsChanged: ProviderAccounts;
+        session_delete: {
+            topic: string;
+        };
+        session_event: SignClientTypes.EventArguments["session_event"];
+        session_update: SignClientTypes.EventArguments["session_delete"];
+        display_uri: string;
+    }
+}
+export interface IEthereumProviderEvents {
+    on: <E extends IProviderEvents.Event>(event: E, listener: (args: IProviderEvents.EventArguments[E]) => void) => EthereumProvider;
+    once: <E extends IProviderEvents.Event>(event: E, listener: (args: IProviderEvents.EventArguments[E]) => void) => EthereumProvider;
+    off: <E extends IProviderEvents.Event>(event: E, listener: (args: IProviderEvents.EventArguments[E]) => void) => EthereumProvider;
+    removeListener: <E extends IProviderEvents.Event>(event: E, listener: (args: IProviderEvents.EventArguments[E]) => void) => EthereumProvider;
+    emit: <E extends IProviderEvents.Event>(event: E, payload: IProviderEvents.EventArguments[E]) => boolean;
+}
+export interface EIP1193Provider {
+    on(event: "connect", listener: (info: ProviderInfo) => void): EthereumProvider;
+    on(event: "disconnect", listener: (error: ProviderRpcError) => void): EthereumProvider;
+    on(event: "message", listener: (message: ProviderMessage) => void): EthereumProvider;
+    on(event: "chainChanged", listener: (chainId: ProviderChainId) => void): EthereumProvider;
+    on(event: "accountsChanged", listener: (accounts: ProviderAccounts) => void): EthereumProvider;
+    request(args: RequestArguments): Promise<unknown>;
+}
+export interface IEthereumProvider extends EIP1193Provider {
+    enable(): Promise<ProviderAccounts>;
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@ledgerhq/connect-kit",
-  "version": "1.1.0-beta.0",
+  "version": "1.1.0-beta.1",
   "description": "A library for dApps to integrate with the Ledger Extension and Ledger Live",
-  "author": "Hugo Lopes",
+  "author": "Ledger SAS <ledger.com>",
   "license": "MIT",
   "main": "dist/umd/index.js",
-  "module": "dist/umd/index.js",
+  "module": "dist/esm/index.js",
   "files": [
     "dist"
   ],
@@ -24,25 +24,32 @@
   "devDependencies": {
     "@rollup/plugin-commonjs": "^22.0.0",
     "@rollup/plugin-image": "^2.1.1",
+    "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^13.3.0",
     "@rollup/plugin-replace": "^4.0.0",
     "@rollup/plugin-typescript": "^8.3.3",
-    "@types/react": "^18.0.13",
-    "@types/react-dom": "^18.0.5",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
     "@types/styled-components": "^5.1.25",
+    "@walletconnect/legacy-provider": "^2.0.0",
+    "@walletconnect/types": "^2.8.0",
+    "@walletconnect/universal-provider": "^2.8.0",
+    "@walletconnect/utils": "^2.8.0",
     "bowser": "^2.11.0",
+    "events": "^3.3.0",
+    "qrcode.react": "^3.1.0",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
     "rollup": "^2.75.6",
+    "rollup-plugin-auto-external": "^2.0.0",
     "rollup-plugin-dts": "^4.2.2",
+    "rollup-plugin-polyfill-node": "^0.12.0",
     "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-url-resolve": "^0.2.0",
+    "rollup-plugin-worker-factory": "^0.5.7",
+    "styled-components": "^5.3.5",
     "tslib": "^2.4.0",
     "typescript": "^4.7.3"
   },
-  "dependencies": {
-    "@walletconnect/ethereum-provider": "^1.8.0",
-    "events": "^3.3.0",
-    "qrcode.react": "^3.1.0",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "styled-components": "^5.3.5"
-  }
+  "dependencies": {}
 }

package/dist/umd/components/ConnectWithLedgerLiveModal/ConnectWithLedgerLiveModal.d.ts

@@ -1,7 +0,0 @@
-import { ModalProps } from "../Modal/Modal";
-export type ConnectWithLedgerLiveModalProps = {
-    isDesktop?: boolean;
-    uri?: string;
-} & ModalProps;
-declare const ConnectWithLedgerLiveModal: ({ isDesktop, uri, onClose, }: ConnectWithLedgerLiveModalProps) => import("react/jsx-runtime").JSX.Element;
-export default ConnectWithLedgerLiveModal;

package/dist/umd/components/ConnectWithLedgerLiveModal/index.d.ts

@@ -1 +0,0 @@
-export { default } from "./ConnectWithLedgerLiveModal";

package/dist/umd/components/ExtensionUnavailableModal/ExtensionUnavailableModal.d.ts

@@ -1,4 +0,0 @@
-import { ModalProps } from "../Modal/Modal";
-export type ExtensionUnavailableModalProps = ModalProps;
-declare const ExtensionUnavailableModal: ({ onClose, }: ExtensionUnavailableModalProps) => import("react/jsx-runtime").JSX.Element;
-export default ExtensionUnavailableModal;

package/dist/umd/components/ExtensionUnavailableModal/index.d.ts

@@ -1 +0,0 @@
-export { default } from "./ExtensionUnavailableModal";

package/dist/umd/lib/connectSupport.d.ts

@@ -1,2 +0,0 @@
-import { Device } from "./browser";
-export declare function isLedgerConnectSupported(device: Device): boolean;

package/dist/umd/providers/Ethereum.d.ts

@@ -1,21 +0,0 @@
-export declare const LEDGER_ETHEREUM_PROVIDER = "ethereum";
-export declare const LEDGER_CONNECT_ETHEREUM_PROP = "isLedgerConnect";
-export type EthereumRequestPayload = {
-    method: string;
-    params?: unknown[] | object;
-};
-export interface EthereumProvider {
-    providers?: EthereumProvider[];
-    connector?: unknown;
-    request<T = unknown>(args: EthereumRequestPayload): Promise<T>;
-    disconnect?: {
-        (): Promise<void>;
-    };
-    emit(eventName: string | symbol, ...args: any[]): boolean;
-    on(event: any, listener: any): void;
-    removeListener(event: string, listener: any): void;
-}
-export interface LedgerConnectProvider extends EthereumProvider {
-    [LEDGER_CONNECT_ETHEREUM_PROP]: boolean;
-}
-export declare function getEthereumProvider(): EthereumProvider;

package/dist/umd/providers/TryConnectEthereum.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="node" />
-import EventEmitter from "events";
-import { EthereumRequestPayload } from "./Ethereum";
-export declare class TryConnectEthereumProvider extends EventEmitter {
-    constructor();
-    request(payload: EthereumRequestPayload): never[] | Promise<unknown>;
-}

package/dist/umd/providers/WalletConnect.d.ts

@@ -1,13 +0,0 @@
-import { EthereumProvider } from './Ethereum';
-export interface initWalletConnectProviderOptions {
-    chainId?: number;
-    bridge?: string;
-    infuraId?: string;
-    rpc?: {
-        [chainId: number]: string;
-    };
-}
-export declare function setWalletConnectOptions(options: initWalletConnectProviderOptions): void;
-export declare function initWalletConnectProvider(): Promise<void>;
-export declare function isWalletConnectProviderConnected(): boolean;
-export declare function getWalletConnectProvider(): Promise<EthereumProvider>;