@solana/wallet-adapter-sollet - npm Package Compare versions

Comparing version 0.5.2 to 0.6.0

lib/adapter.d.ts

 import { BaseSignerWalletAdapter, WalletAdapterNetwork } from '@solana/wallet-adapter-base';
 import { PublicKey, Transaction } from '@solana/web3.js';
-declare type SolletProvider = string | {
+interface SolletWallet {
     postMessage(...args: unknown[]): unknown;
-};
+}
 export interface SolletWalletAdapterConfig {
-    provider?: SolletProvider;
+    provider?: string | SolletWallet;
     network?: WalletAdapterNetwork;
+    pollInterval?: number;
+    pollCount?: number;
 }
@@ -10,0 +12,0 @@ export declare class SolletWalletAdapter extends BaseSignerWalletAdapter {

lib/adapter.js

@@ -30,6 +30,8 @@ "use strict";
         };
-        this._provider = config.provider || 'https://www.sollet.io';
+        this._provider = config.provider || (typeof window === 'undefined' ? undefined : window.sollet);
         this._network = config.network || wallet_adapter_base_1.WalletAdapterNetwork.Mainnet;
         this._connecting = false;
         this._wallet = null;
+        if (!this.ready)
+            (0, wallet_adapter_base_1.pollUntilReady)(this, config.pollInterval || 1000, config.pollCount || 3);
     }
@@ -41,4 +43,5 @@ get publicKey() {
     get ready() {
-        // @FIXME
-        return typeof window !== 'undefined';
+        var _a;
+        return (typeof this._provider === 'string' ||
+            (typeof window !== 'undefined' && typeof ((_a = window.sollet) === null || _a === void 0 ? void 0 : _a.postMessage) === 'function'));
     }
@@ -62,33 +65,62 @@ get connecting() {
                 this._connecting = true;
+                const provider = this._provider || (typeof window !== 'undefined' && window.sollet);
+                if (!provider)
+                    throw new wallet_adapter_base_1.WalletNotFoundError();
                 let wallet;
-                let interval;
                 try {
-                    wallet = new sol_wallet_adapter_1.default(this._provider, this._network);
-                    // HACK: sol-wallet-adapter doesn't reject or emit an event if the popup is closed or blocked
-                    yield new Promise((resolve, reject) => {
-                        wallet.connect().then(resolve, reject);
-                        if (typeof this._provider === 'string') {
-                            let count = 0;
-                            interval = setInterval(() => {
-                                const popup = wallet._popup;
-                                if (popup) {
-                                    if (popup.closed)
-                                        reject(new wallet_adapter_base_1.WalletWindowClosedError());
-                                }
-                                else {
-                                    if (count > 50)
-                                        reject(new wallet_adapter_base_1.WalletWindowBlockedError());
-                                }
-                                count++;
-                            }, 100);
-                        }
-                    });
+                    wallet = new sol_wallet_adapter_1.default(provider, this._network);
+                    // HACK: sol-wallet-adapter doesn't reject or emit an event if the popup or extension is closed or blocked
+                    const handleDisconnect = wallet.handleDisconnect;
+                    let timeout;
+                    let interval;
+                    try {
+                        yield new Promise((resolve, reject) => {
+                            const connect = () => {
+                                if (timeout)
+                                    clearTimeout(timeout);
+                                wallet.off('connect', connect);
+                                resolve();
+                            };
+                            wallet.handleDisconnect = (...args) => {
+                                wallet.off('connect', connect);
+                                reject(new wallet_adapter_base_1.WalletWindowClosedError());
+                                return handleDisconnect.apply(wallet, args);
+                            };
+                            wallet.on('connect', connect);
+                            wallet.connect().catch((reason) => {
+                                wallet.off('connect', connect);
+                                reject(reason);
+                            });
+                            if (typeof provider === 'string') {
+                                let count = 0;
+                                interval = setInterval(() => {
+                                    const popup = wallet._popup;
+                                    if (popup) {
+                                        if (popup.closed)
+                                            reject(new wallet_adapter_base_1.WalletWindowClosedError());
+                                    }
+                                    else {
+                                        if (count > 50)
+                                            reject(new wallet_adapter_base_1.WalletWindowBlockedError());
+                                    }
+                                    count++;
+                                }, 100);
+                            }
+                            else {
+                                // HACK: sol-wallet-adapter doesn't reject or emit an event if the extension is closed or ignored
+                                timeout = setTimeout(() => reject(new wallet_adapter_base_1.WalletTimeoutError()), 10000);
+                            }
+                        });
+                    }
+                    finally {
+                        wallet.handleDisconnect = handleDisconnect;
+                        if (interval)
+                            clearInterval(interval);
+                    }
                 }
                 catch (error) {
+                    if (error instanceof wallet_adapter_base_1.WalletError)
+                        throw error;
                     throw new wallet_adapter_base_1.WalletConnectionError(error === null || error === void 0 ? void 0 : error.message, error);
                 }
-                finally {
-                    if (interval)
-                        clearInterval(interval);
-                }
                 wallet.on('disconnect', this._disconnected);
@@ -113,4 +145,26 @@ this._wallet = wallet;
                 this._wallet = null;
+                // HACK: sol-wallet-adapter doesn't reliably fulfill its promise or emit an event on disconnect
+                const handleDisconnect = wallet.handleDisconnect;
                 try {
-                    yield wallet.disconnect();
+                    yield new Promise((resolve, reject) => {
+                        const timeout = setTimeout(() => resolve(), 250);
+                        wallet.handleDisconnect = (...args) => {
+                            clearTimeout(timeout);
+                            resolve();
+                            return handleDisconnect.apply(wallet, args);
+                        };
+                        wallet.disconnect().then(() => {
+                            clearTimeout(timeout);
+                            resolve();
+                        }, (error) => {
+                            clearTimeout(timeout);
+                            // HACK: sol-wallet-adapter rejects with an error on disconnect
+                            if (error.message === 'Wallet disconnected') {
+                                resolve();
+                            }
+                            else {
+                                reject(error);
+                            }
+                        });
+                    });
                 }
@@ -120,2 +174,5 @@ catch (error) {
                 }
+                finally {
+                    wallet.handleDisconnect = handleDisconnect;
+                }
                 this.emit('disconnect');
@@ -122,0 +179,0 @@ }

package.json

 {
     "name": "@solana/wallet-adapter-sollet",
-    "version": "0.5.2",
+    "version": "0.6.0",
     "author": "Solana Maintainers <[e-mail]>",
@@ -33,3 +33,3 @@ "repository": "https://github.com/solana-labs/wallet-adapter",
     },
-    "gitHead": "f1c15aa0c22d2fa6a566bc095f05e4fde4745230"
+    "gitHead": "139856c15453e583411b162a927c42f3c99ca158"
 }

src/adapter.ts

 import Wallet from '@project-serum/sol-wallet-adapter';
 import {
     BaseSignerWalletAdapter,
+    pollUntilReady,
     WalletAdapterNetwork,
@@ -8,4 +9,7 @@ WalletConnectionError,
     WalletDisconnectionError,
+    WalletError,
     WalletNotConnectedError,
+    WalletNotFoundError,
     WalletSignTransactionError,
+    WalletTimeoutError,
     WalletWindowBlockedError,
@@ -16,11 +20,21 @@ WalletWindowClosedError,
 
-type SolletProvider = string | { postMessage(...args: unknown[]): unknown };
+interface SolletWallet {
+    postMessage(...args: unknown[]): unknown;
+}
 
+interface SolletWindow extends Window {
+    sollet?: SolletWallet;
+}
+
+declare const window: SolletWindow;
+
 export interface SolletWalletAdapterConfig {
-    provider?: SolletProvider;
+    provider?: string | SolletWallet;
     network?: WalletAdapterNetwork;
+    pollInterval?: number;
+    pollCount?: number;
 }
 
 export class SolletWalletAdapter extends BaseSignerWalletAdapter {
-    private _provider: SolletProvider;
+    private _provider: string | SolletWallet | undefined;
     private _network: WalletAdapterNetwork;
@@ -32,6 +46,8 @@ private _connecting: boolean;
         super();
-        this._provider = config.provider || 'https://www.sollet.io';
+        this._provider = config.provider || (typeof window === 'undefined' ? undefined : window.sollet);
         this._network = config.network || WalletAdapterNetwork.Mainnet;
         this._connecting = false;
         this._wallet = null;
+
+        if (!this.ready) pollUntilReady(this, config.pollInterval || 1000, config.pollCount || 3);
     }
@@ -44,4 +60,6 @@
     get ready(): boolean {
-        // @FIXME
-        return typeof window !== 'undefined';
+        return (
+            typeof this._provider === 'string' ||
+            (typeof window !== 'undefined' && typeof window.sollet?.postMessage === 'function')
+        );
     }
@@ -66,30 +84,59 @@
 
+            const provider = this._provider || (typeof window !== 'undefined' && window.sollet);
+            if (!provider) throw new WalletNotFoundError();
+
             let wallet: Wallet;
-            let interval: NodeJS.Timer | undefined;
             try {
-                wallet = new Wallet(this._provider, this._network);
+                wallet = new Wallet(provider, this._network);
 
-                // HACK: sol-wallet-adapter doesn't reject or emit an event if the popup is closed or blocked
-                await new Promise<void>((resolve, reject) => {
-                    wallet.connect().then(resolve, reject);
+                // HACK: sol-wallet-adapter doesn't reject or emit an event if the popup or extension is closed or blocked
+                const handleDisconnect: (...args: unknown[]) => unknown = (wallet as any).handleDisconnect;
+                let timeout: NodeJS.Timer | undefined;
+                let interval: NodeJS.Timer | undefined;
+                try {
+                    await new Promise<void>((resolve, reject) => {
+                        const connect = () => {
+                            if (timeout) clearTimeout(timeout);
+                            wallet.off('connect', connect);
+                            resolve();
+                        };
 
-                    if (typeof this._provider === 'string') {
-                        let count = 0;
+                        (wallet as any).handleDisconnect = (...args: unknown[]): unknown => {
+                            wallet.off('connect', connect);
+                            reject(new WalletWindowClosedError());
+                            return handleDisconnect.apply(wallet, args);
+                        };
 
-                        interval = setInterval(() => {
-                            const popup = (wallet as any)._popup;
-                            if (popup) {
-                                if (popup.closed) reject(new WalletWindowClosedError());
-                            } else {
-                                if (count > 50) reject(new WalletWindowBlockedError());
-                            }
+                        wallet.on('connect', connect);
 
-                            count++;
-                        }, 100);
-                    }
-                });
+                        wallet.connect().catch((reason: any) => {
+                            wallet.off('connect', connect);
+                            reject(reason);
+                        });
+
+                        if (typeof provider === 'string') {
+                            let count = 0;
+
+                            interval = setInterval(() => {
+                                const popup = (wallet as any)._popup;
+                                if (popup) {
+                                    if (popup.closed) reject(new WalletWindowClosedError());
+                                } else {
+                                    if (count > 50) reject(new WalletWindowBlockedError());
+                                }
+
+                                count++;
+                            }, 100);
+                        } else {
+                            // HACK: sol-wallet-adapter doesn't reject or emit an event if the extension is closed or ignored
+                            timeout = setTimeout(() => reject(new WalletTimeoutError()), 10000);
+                        }
+                    });
+                } finally {
+                    (wallet as any).handleDisconnect = handleDisconnect;
+                    if (interval) clearInterval(interval);
+                }
             } catch (error: any) {
+                if (error instanceof WalletError) throw error;
                 throw new WalletConnectionError(error?.message, error);
-            } finally {
-                if (interval) clearInterval(interval);
             }
@@ -117,6 +164,34 @@
 
+            // HACK: sol-wallet-adapter doesn't reliably fulfill its promise or emit an event on disconnect
+            const handleDisconnect: (...args: unknown[]) => unknown = (wallet as any).handleDisconnect;
             try {
-                await wallet.disconnect();
+                await new Promise<void>((resolve, reject) => {
+                    const timeout = setTimeout(() => resolve(), 250);
+
+                    (wallet as any).handleDisconnect = (...args: unknown[]): unknown => {
+                        clearTimeout(timeout);
+                        resolve();
+                        return handleDisconnect.apply(wallet, args);
+                    };
+
+                    wallet.disconnect().then(
+                        () => {
+                            clearTimeout(timeout);
+                            resolve();
+                        },
+                        (error) => {
+                            clearTimeout(timeout);
+                            // HACK: sol-wallet-adapter rejects with an error on disconnect
+                            if (error.message === 'Wallet disconnected') {
+                                resolve();
+                            } else {
+                                reject(error);
+                            }
+                        }
+                    );
+                });
             } catch (error: any) {
                 this.emit('error', new WalletDisconnectionError(error?.message, error));
+            } finally {
+                (wallet as any).handleDisconnect = handleDisconnect;
             }
@@ -123,0 +198,0 @@

Fixed alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

38500

29.91%

Lines of code

462

37.09%

Number of low supply chain risk alerts

1

-50%

No dependency changes