@wallet01/core - npm Package Compare versions

Comparing version 0.6.5 to 1.0.0-beta.0

CHANGELOG.md

 # @wallet01/core
 
+## 1.0.0-beta.0
+
+### Major Changes
+
+- New events based architecture Wallet01; updated connectors and react package
+
 ## 0.6.5
@@ -4,0 +10,0 @@

dist/client/client.d.ts

@@ -1,15 +0,14 @@
-import { BaseConnector } from "../types";
+import { ClientEvents, ConnectorEvents } from "../types/events";
+import { ClientConfig } from "../types/methodTypes";
+import { EnhancedEventEmitter } from "../utils/EnhancedEventEmitter";
 import { Wallet01Store } from "./store";
-type ClientConfig = {
-    autoConnect?: boolean;
-    connectors: BaseConnector[];
-};
-export default class Client extends Wallet01Store {
-    private static instance;
-    activeConnector: BaseConnector | null;
-    constructor({ autoConnect, connectors }: ClientConfig);
-    static init: (config: ClientConfig) => Client;
-    private ac;
+export default class Wallet01Client {
+    #private;
+    readonly emitter: EnhancedEventEmitter<ConnectorEvents & ClientEvents>;
+    store: Wallet01Store;
+    private constructor();
+    static init: (config: ClientConfig) => Wallet01Client;
+    private registerEventListeners;
+    private autoConnect;
 }
-export {};
 //# sourceMappingURL=client.d.ts.map

dist/client/store.d.ts

@@ -0,24 +1,23 @@
+import { IState } from "../store/storeTypes";
 import { BaseConnector } from "../types";
 export declare class Wallet01Store {
-    getActiveChain(): "ethereum" | "solana" | "cosmos" | "tezos" | null;
+    #private;
+    private constructor();
+    static init(): Wallet01Store;
+    getState: () => IState;
+    getEcosystem(): import("../store/storeTypes").TEcosystem | null;
     getAddress(): string | null;
-    getDid(): string | null;
+    getAddresses(): string[];
     getIsConnected(): boolean;
     getChain(): string | null;
-    getAutoConnect(): boolean;
     getConnectors(): BaseConnector[];
     getActiveConnector(): BaseConnector | null;
-    getLastUsedConnector(): BaseConnector | null;
-    getIsAutoConnecting(): boolean;
-    setActiveChain(activeChain: "ethereum" | "solana" | "cosmos" | "tezos" | null): void;
+    setEcosystem(ecosystem: "ethereum" | "solana" | "cosmos" | "tezos" | null): void;
     setAddress(address: string | null): void;
-    setDid(did: string | null): void;
+    setAddresses(addresses: string[]): void;
     setIsConnected(val: boolean): void;
-    setChainId(id: string | null): void;
-    setAutoConnect(val: boolean): void;
+    setChainId(id: string | "mainnet" | null): void;
     setConnectors(connectors: BaseConnector[]): void;
     setActiveConnector(connector: BaseConnector | null): void;
-    setLastUsedConnector(connector: BaseConnector | null): void;
-    setIsAutoConnecting(val: boolean): void;
 }
 //# sourceMappingURL=store.d.ts.map

dist/index.d.ts

 import Client from "./client/client";
-import { useStore } from "./store/rootStore";
-import { type ClientConfig, type ConnectedData, BaseConnector, TProvider } from "./types";
-import setLastUsedConnector from "./utils/util";
-export { Client, type ClientConfig, type ConnectedData, type TProvider, BaseConnector, setLastUsedConnector, useStore, };
+import { useStore, getState, setState } from "./store/rootStore";
+import { BaseConnector } from "./types/BaseConnector";
+import setLastUsedConnector from "./utils";
+export { Client, BaseConnector, setLastUsedConnector };
+export { useStore, getState, setState };
+export * from "./utils/errors";
 //# sourceMappingURL=index.d.ts.map

dist/index.js

@@ -1,24 +0,442 @@
-import "./chunk-RZMIDZ2N.js";
-import {
-  BaseConnector
-} from "./chunk-KIV25KVU.js";
-import {
-  util_default
-} from "./chunk-DUPRLLUL.js";
-import {
-  Client
-} from "./chunk-DMDDQH2A.js";
-import "./chunk-5PL23P3E.js";
-import {
-  useStore
-} from "./chunk-5PBDKPYG.js";
-import "./chunk-4A3ZCJ3K.js";
-import "./chunk-QZZ2GP5E.js";
-import "./chunk-W7E5PEDQ.js";
-import "./chunk-XXPGZHWZ.js";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/utils/EnhancedEventEmitter.ts
+import { EventEmitter } from "events";
+var _instance;
+var _EnhancedEventEmitter = class {
+  constructor() {
+    __publicField(this, "emitter");
+    this.emitter = new EventEmitter();
+    this.emitter.setMaxListeners(Infinity);
+  }
+  on(eventName, listener) {
+    this.emitter.on(
+      eventName,
+      listener
+    );
+    return this;
+  }
+  off(eventName, listener) {
+    this.emitter.off(
+      eventName,
+      listener
+    );
+    return this;
+  }
+  listenerCount(eventName) {
+    return this.emitter.listenerCount(eventName);
+  }
+  listeners(eventName) {
+    return this.emitter.listeners(eventName);
+  }
+  emit(eventName, ...args) {
+    return this.emitter.emit(eventName, ...args);
+  }
+  safeEmit(eventName, ...args) {
+    return this.emitter.emit(eventName, ...args);
+  }
+  once(eventName, listener) {
+    this.emitter.once(
+      eventName,
+      listener
+    );
+    return this;
+  }
+  removeAllListeners(eventName) {
+    if (eventName) {
+      this.emitter.removeAllListeners(eventName);
+    } else {
+      this.emitter.removeAllListeners();
+    }
+    return this;
+  }
+};
+var EnhancedEventEmitter = _EnhancedEventEmitter;
+_instance = new WeakMap();
+__privateAdd(EnhancedEventEmitter, _instance, void 0);
+__publicField(EnhancedEventEmitter, "init", () => {
+  if (!__privateGet(_EnhancedEventEmitter, _instance))
+    __privateSet(_EnhancedEventEmitter, _instance, new _EnhancedEventEmitter());
+  return __privateGet(_EnhancedEventEmitter, _instance);
+});
+
+// src/store/rootStore.ts
+import create from "zustand";
+
+// src/store/createAccountSlice.ts
+var createAccountSlice = (set) => ({
+  address: null,
+  addresses: [],
+  setAddress: (address) => {
+    set(() => ({ address }));
+  },
+  setAddresses: (addresses) => {
+    set(() => ({ addresses }));
+  }
+});
+var createAccountSlice_default = createAccountSlice;
+
+// src/store/createClientSlice.ts
+var createClientSlice = (set) => ({
+  ecosystem: null,
+  connectors: [],
+  activeConnector: null,
+  setEcosystem: (ecosystem) => {
+    set(() => ({ ecosystem }));
+  },
+  setConnectors: (connectors) => {
+    set(() => ({ connectors }));
+  },
+  setActiveConnector: (activeConnector) => {
+    set(() => ({ activeConnector }));
+  }
+});
+var createClientSlice_default = createClientSlice;
+
+// src/store/createWalletSlice.ts
+var createWalletSlice = (set) => ({
+  isConnected: false,
+  chainId: "mainnet",
+  setIsConnected: (isConnected) => {
+    set(() => ({ isConnected }));
+  },
+  setChainId: (chainId) => {
+    set(() => ({ chainId }));
+  }
+});
+var createWalletSlice_default = createWalletSlice;
+
+// src/store/rootStore.ts
+var useStore = create()((...a) => ({
+  ...createAccountSlice_default(...a),
+  ...createWalletSlice_default(...a),
+  ...createClientSlice_default(...a)
+}));
+var { getState, setState } = useStore;
+
+// src/client/store.ts
+var _instance2;
+var _Wallet01Store = class {
+  constructor() {
+    __publicField(this, "getState");
+    this.getState = getState;
+  }
+  static init() {
+    if (!__privateGet(_Wallet01Store, _instance2)) {
+      __privateSet(_Wallet01Store, _instance2, new _Wallet01Store());
+    }
+    return __privateGet(_Wallet01Store, _instance2);
+  }
+  getEcosystem() {
+    const { ecosystem } = getState();
+    return ecosystem;
+  }
+  getAddress() {
+    const { address } = getState();
+    return address;
+  }
+  getAddresses() {
+    const { addresses } = getState();
+    return addresses;
+  }
+  getIsConnected() {
+    const { isConnected } = getState();
+    return isConnected;
+  }
+  getChain() {
+    const { chainId } = getState();
+    return chainId;
+  }
+  getConnectors() {
+    const { connectors } = getState();
+    return connectors;
+  }
+  getActiveConnector() {
+    const { activeConnector } = getState();
+    return activeConnector;
+  }
+  setEcosystem(ecosystem) {
+    const { setEcosystem } = getState();
+    setEcosystem(ecosystem);
+  }
+  setAddress(address) {
+    const { setAddress } = getState();
+    setAddress(address);
+  }
+  setAddresses(addresses) {
+    const { setAddresses } = getState();
+    setAddresses(addresses);
+  }
+  setIsConnected(val) {
+    const { setIsConnected } = getState();
+    setIsConnected(val);
+  }
+  setChainId(id) {
+    const { setChainId } = getState();
+    setChainId(id);
+  }
+  setConnectors(connectors) {
+    const { setConnectors } = getState();
+    setConnectors(connectors);
+  }
+  setActiveConnector(connector) {
+    const { setActiveConnector } = getState();
+    setActiveConnector(connector);
+  }
+};
+var Wallet01Store = _Wallet01Store;
+_instance2 = new WeakMap();
+__privateAdd(Wallet01Store, _instance2, void 0);
+
+// src/client/client.ts
+var _instance3;
+var _Wallet01Client = class {
+  constructor({ autoConnect = false, connectors }) {
+    __publicField(this, "emitter");
+    __publicField(this, "store", Wallet01Store.init());
+    this.emitter = EnhancedEventEmitter.init();
+    this.store.setConnectors(connectors);
+    console.log("Creating client class");
+    this.registerEventListeners();
+    if (localStorage.getItem("autoConnect") === null)
+      localStorage.setItem("autoConnect", String(autoConnect));
+    if (localStorage.getItem("autoConnect") === "false") {
+      return;
+    }
+    if (localStorage.getItem("autoConnect") !== String(autoConnect))
+      localStorage.setItem("autoConnect", String(autoConnect));
+    if (!localStorage.getItem("lastUsedConnector")) {
+      return;
+    }
+    if (localStorage.getItem("lastUsedConnector") && localStorage.getItem("autoConnect") === "true") {
+      this.autoConnect();
+    }
+  }
+  registerEventListeners() {
+    this.emitter.on(
+      "connected",
+      (address, chainId, walletName, ecosystem, activeConnector) => {
+        localStorage.setItem("lastUsedConnector", walletName);
+        this.store.setActiveConnector(activeConnector);
+        this.store.setAddress(address);
+        this.store.setChainId(chainId);
+        this.store.setEcosystem(ecosystem);
+        this.store.setIsConnected(true);
+      }
+    );
+    this.emitter.on("disconnected", () => {
+      localStorage.removeItem("lastUsedConnector");
+      this.store.setActiveConnector(null);
+      this.store.setAddress(null);
+      this.store.setChainId(null);
+      this.store.setEcosystem(null);
+      this.store.setIsConnected(false);
+    });
+    this.emitter.on(
+      "switchingChain",
+      async (_f, toChainId, activeConnector) => {
+        const accounts = await activeConnector.getAccount();
+        if (accounts[0])
+          this.store.setAddress(accounts[0]);
+        this.store.setActiveConnector(activeConnector);
+        this.store.setChainId(toChainId);
+      }
+    );
+    this.emitter.on("chainChanged", (chainId) => {
+      this.store.setChainId(chainId);
+    });
+    this.emitter.on("accountsChanged", (addresses) => {
+      console.log("accountsChanged", addresses);
+      this.store.setAddresses(addresses);
+      if (addresses[0])
+        this.store.setAddress(addresses[0]);
+    });
+  }
+  async autoConnect() {
+    const lastUsedConnectorName = localStorage.getItem("lastUsedConnector");
+    if (!lastUsedConnectorName) {
+      console.info({
+        message: "No last used connector found"
+      });
+      return;
+    }
+    const lastUsedConnector = this.store.getConnectors().find((conn) => conn.name === lastUsedConnectorName);
+    if (!lastUsedConnector) {
+      console.warn({
+        message: `The connector for wallet name: ${lastUsedConnectorName} was not found in the list of connectors`
+      });
+      return;
+    }
+    this.store.setActiveConnector(lastUsedConnector);
+    const activeConnector = this.store.getActiveConnector();
+    if (activeConnector) {
+      this.emitter.emit(
+        "isAutoConnecting",
+        activeConnector.ecosystem,
+        activeConnector
+      );
+      await activeConnector.connect();
+    }
+  }
+};
+var Wallet01Client = _Wallet01Client;
+_instance3 = new WeakMap();
+__privateAdd(Wallet01Client, _instance3, void 0);
+__publicField(Wallet01Client, "init", (config) => {
+  if (!__privateGet(_Wallet01Client, _instance3))
+    __privateSet(_Wallet01Client, _instance3, new _Wallet01Client(config));
+  return __privateGet(_Wallet01Client, _instance3);
+});
+
+// src/types/BaseConnector.ts
+var BaseConnector = class {
+  constructor(name, ecosystem) {
+    __publicField(this, "name");
+    __publicField(this, "ecosystem");
+    __publicField(this, "emitter", EnhancedEventEmitter.init());
+    this.name = name;
+    this.ecosystem = ecosystem;
+  }
+};
+
+// src/utils/index.ts
+var setLastUsedConnector = (connectorName) => {
+  if (localStorage.getItem("lastUsedConnector") !== connectorName)
+    localStorage.setItem("lastUsedConnector", connectorName);
+};
+var utils_default = setLastUsedConnector;
+
+// src/utils/errors.ts
+var AutoConnectionError = class extends Error {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "name", "AutoConnectionError");
+  }
+};
+var ProviderNotFoundError = class extends Error {
+  constructor({ walletName }) {
+    super();
+    __publicField(this, "name", "ProviderNotFoundError");
+    __publicField(this, "walletName");
+    this.walletName = walletName;
+  }
+};
+var WalletConnectionError = class extends Error {
+  constructor({ walletName }) {
+    super(`Error while connecting to ${walletName} wallet.`);
+    __publicField(this, "name", "WalletConnectionError");
+    __publicField(this, "walletName");
+    this.walletName = walletName;
+  }
+};
+var WalletNotConnectedError = class extends Error {
+  constructor({ walletName }) {
+    super(`${walletName} wallet is not connected.`);
+    __publicField(this, "name", "WalletNotConnectedError");
+    __publicField(this, "walletName");
+    this.walletName = walletName;
+  }
+};
+var UnknownError = class extends Error {
+  constructor({
+    walletName,
+    atFunction
+  }) {
+    super(
+      `There was an unexpected error while using ${walletName} wallet at ${atFunction}(). Check console for more details.`
+    );
+    __publicField(this, "name", "UnknownError");
+  }
+};
+var UserRejectedRequestError = class extends Error {
+  constructor() {
+    super(`User rejected the request.`);
+    __publicField(this, "name", "UserRejectedRequestError");
+  }
+};
+var UnsupportedChainError = class extends Error {
+  constructor({ chainId }) {
+    super(`ChainId: ${chainId} is not supported`);
+    __publicField(this, "name", "UnsupportedChainError");
+    __publicField(this, "chainId");
+    this.chainId = chainId;
+  }
+};
+var WalletCreationError = class extends Error {
+  constructor({ walletName }) {
+    super(`Error while creating ${walletName} wallet.`);
+    __publicField(this, "name", "WalletCreationError");
+  }
+};
+var MessageSignError = class extends Error {
+  constructor({ walletName }) {
+    super(`Error while signing message with ${walletName} wallet.`);
+    __publicField(this, "name", "MessageSignError");
+  }
+};
+var UnrecognisedChainError = class extends Error {
+  constructor({
+    walletName,
+    chainId
+  }) {
+    super(
+      `Unrecognised chainId ${chainId} provided. Please provide options to add chain to ${walletName} wallet.`
+    );
+    __publicField(this, "name", "UnrecognisedChainError");
+  }
+};
+var AddressNotFoundError = class extends Error {
+  constructor({ walletName }) {
+    super(`Address not found in ${walletName} wallet.`);
+    __publicField(this, "name", "AddressNotFoundError");
+  }
+};
+var WalletNotInstalledError = class extends Error {
+  constructor({ walletName }) {
+    super(`${walletName} wallet is not installed.`);
+    __publicField(this, "name", "WalletNotInstalledError");
+  }
+};
 export {
+  AddressNotFoundError,
+  AutoConnectionError,
   BaseConnector,
-  Client,
-  util_default as setLastUsedConnector,
+  Wallet01Client as Client,
+  MessageSignError,
+  ProviderNotFoundError,
+  UnknownError,
+  UnrecognisedChainError,
+  UnsupportedChainError,
+  UserRejectedRequestError,
+  WalletConnectionError,
+  WalletCreationError,
+  WalletNotConnectedError,
+  WalletNotInstalledError,
+  getState,
+  utils_default as setLastUsedConnector,
+  setState,
   useStore
 };

dist/store/createAccountSlice.d.ts

@@ -1,3 +0,3 @@
-import { StateCreator } from 'zustand';
-import { IAccountState } from './storeTypes';
+import { StateCreator } from "zustand";
+import { IAccountState } from "./storeTypes";
 declare const createAccountSlice: StateCreator<IAccountState, [
@@ -4,0 +4,0 @@ ], [

dist/store/createWalletSlice.d.ts

@@ -1,3 +0,3 @@
-import { StateCreator } from 'zustand';
-import { IWalletState } from './storeTypes';
+import { StateCreator } from "zustand";
+import { IWalletState } from "./storeTypes";
 declare const createWalletSlice: StateCreator<IWalletState, [
@@ -4,0 +4,0 @@ ], [

dist/store/rootStore.d.ts

@@ -1,5 +0,4 @@
-import { IState } from './storeTypes';
+import { IState } from "./storeTypes";
 export declare const useStore: import("zustand").UseBoundStore<import("zustand").StoreApi<IState>>;
-declare const getState: () => IState;
-export default getState;
+export declare const getState: () => IState, setState: (partial: IState | Partial<IState> | ((state: IState) => IState | Partial<IState>), replace?: boolean | undefined) => void;
 //# sourceMappingURL=rootStore.d.ts.map

dist/store/storeTypes.d.ts

 import { BaseConnector } from "../types";
+export type TEcosystem = "ethereum" | "solana" | "cosmos" | "tezos";
 export interface IAccountState {
     address: string | null;
-    did: string | null;
+    addresses: string[];
     setAddress: (address: string | null) => void;
-    setDid: (did: string | null) => void;
+    setAddresses: (addresses: string[]) => void;
 }
 export interface IWalletState {
     isConnected: boolean;
-    chainId: string | null;
+    chainId: "mainnet" | string | null;
     setIsConnected: (val: boolean) => void;
-    setChainId: (id: string | null) => void;
+    setChainId: (id: "mainnet" | string | null) => void;
 }
 export interface IClientState {
-    activeChain: "ethereum" | "solana" | "cosmos" | "tezos" | null;
-    autoConnect: boolean;
+    ecosystem: TEcosystem | null;
     connectors: BaseConnector[];
     activeConnector: BaseConnector | null;
-    lastUsedConnector: BaseConnector | null;
-    isAutoConnecting: boolean;
-    setActiveChain: (val: "ethereum" | "solana" | "cosmos" | "tezos" | null) => void;
-    setAutoConnect: (val: boolean) => void;
+    setEcosystem: (val: TEcosystem | null) => void;
     setConnectors: (connectors: BaseConnector[]) => void;
     setActiveConnector: (connector: BaseConnector | null) => void;
-    setLastUsedConnector: (connector: BaseConnector | null) => void;
-    setIsAutoConnecting: (val: boolean) => void;
 }
 export type IState = IAccountState & IWalletState & IClientState;
 //# sourceMappingURL=storeTypes.d.ts.map

dist/types/index.d.ts

@@ -1,13 +0,3 @@
-import { BaseConnector } from './baseConnector';
-import { TProvider } from './TProvider';
-type ClientConfig<TProvider> = {
-    chainId: string;
-    connector: BaseConnector<TProvider>;
-};
-type ConnectedData<TProvider> = {
-    account: string;
-    chainId: string;
-    provider: TProvider;
-};
-export { type ClientConfig, type ConnectedData, BaseConnector, type TProvider };
+import { BaseConnector } from "./BaseConnector";
+export { BaseConnector };
 //# sourceMappingURL=index.d.ts.map

package.json

 {
   "name": "@wallet01/core",
-  "version": "0.6.5",
+  "version": "1.0.0-beta.0",
   "description": "",
@@ -5,0 +5,0 @@ "main": "dist/index.cjs",

src/client/client.ts

@@ -1,23 +0,26 @@
-import { BaseConnector } from "../types";
+import { ClientEvents, ConnectorEvents } from "../types/events";
+import { ClientConfig } from "../types/methodTypes";
+import { EnhancedEventEmitter } from "../utils/EnhancedEventEmitter";
 import { Wallet01Store } from "./store";
 
-type ClientConfig = {
-  autoConnect?: boolean;
-  connectors: BaseConnector[];
-};
+export default class Wallet01Client {
+  static #instance: Wallet01Client;
+  public readonly emitter: EnhancedEventEmitter<ConnectorEvents & ClientEvents>;
 
-export default class Client extends Wallet01Store {
-  private static instance: Client;
-  activeConnector: BaseConnector | null = null;
+  public store: Wallet01Store = Wallet01Store.init();
 
-  constructor({ autoConnect, connectors }: ClientConfig) {
-    super();
-    this.setAutoConnect(autoConnect || false);
-    this.setConnectors(connectors);
+  private constructor({ autoConnect = false, connectors }: ClientConfig) {
+    this.emitter = EnhancedEventEmitter.init();
+    this.store.setConnectors(connectors);
 
+    console.log("Creating client class");
+
+    this.registerEventListeners();
+
     if (localStorage.getItem("autoConnect") === null)
       localStorage.setItem("autoConnect", String(autoConnect));
 
-    if (localStorage.getItem("autoConnect") === "false")
-      this.setIsAutoConnecting(false);
+    if (localStorage.getItem("autoConnect") === "false") {
+      return;
+    }
 
@@ -27,4 +30,5 @@ if (localStorage.getItem("autoConnect") !== String(autoConnect))
 
-    if (!localStorage.getItem("lastUsedConnector"))
-      this.setIsAutoConnecting(false);
+    if (!localStorage.getItem("lastUsedConnector")) {
+      return;
+    }
 
@@ -35,3 +39,3 @@ if (
     ) {
-      this.ac();
+      this.autoConnect();
     }
@@ -41,63 +45,86 @@ }
   static init = (config: ClientConfig) => {
-    if (!Client.instance) Client.instance = new Client(config);
-    return Client.instance;
+    if (!Wallet01Client.#instance)
+      Wallet01Client.#instance = new Wallet01Client(config);
+    return Wallet01Client.#instance;
   };
 
-  private async ac() {
-    try {
-      this.setIsAutoConnecting(true);
-      const lastConnName = localStorage.getItem("lastUsedConnector");
-      if (!lastConnName) {
-        this.setIsAutoConnecting(false);
-        return;
+  private registerEventListeners() {
+    // this.on("isAutoConnecting", (ecosystem) => {})
+    this.emitter.on(
+      "connected",
+      (address, chainId, walletName, ecosystem, activeConnector) => {
+        localStorage.setItem("lastUsedConnector", walletName);
+        this.store.setActiveConnector(activeConnector);
+        this.store.setAddress(address);
+        this.store.setChainId(chainId);
+        this.store.setEcosystem(ecosystem);
+        this.store.setIsConnected(true);
       }
+    );
 
-      const connector = this.getConnectors().find(
-        conn => conn.name === lastConnName
-      );
+    this.emitter.on("disconnected", () => {
+      localStorage.removeItem("lastUsedConnector");
+      this.store.setActiveConnector(null);
+      this.store.setAddress(null);
+      this.store.setChainId(null);
+      this.store.setEcosystem(null);
+      this.store.setIsConnected(false);
+    });
 
-      if (!connector) {
-        this.setIsAutoConnecting(false);
-        return;
-      } else this.setLastUsedConnector(connector);
+    this.emitter.on(
+      "switchingChain",
+      async (_f, toChainId, activeConnector) => {
+        const accounts = await activeConnector.getAccount();
+        if (accounts[0]) this.store.setAddress(accounts[0]);
+        this.store.setActiveConnector(activeConnector);
+        this.store.setChainId(toChainId);
+      }
+    );
 
-      this.setActiveConnector(this.getLastUsedConnector());
-      this.activeConnector = this.getLastUsedConnector();
+    this.emitter.on("chainChanged", chainId => {
+      this.store.setChainId(chainId);
+    });
 
-      if (this.activeConnector) {
-        await this.activeConnector.connect({});
-        const addresses = await this.activeConnector.getAccount();
+    this.emitter.on("accountsChanged", addresses => {
+      console.log("accountsChanged", addresses);
+      this.store.setAddresses(addresses);
+      if (addresses[0]) this.store.setAddress(addresses[0]);
+    });
+  }
 
-        const address = addresses[0];
+  private async autoConnect() {
+    const lastUsedConnectorName = localStorage.getItem("lastUsedConnector");
 
-        if (!address) return;
+    if (!lastUsedConnectorName) {
+      console.info({
+        message: "No last used connector found",
+      });
+      return;
+    }
 
-        this.setAddress(address);
+    const lastUsedConnector = this.store
+      .getConnectors()
+      .find(conn => conn.name === lastUsedConnectorName);
 
-        const did = await this.activeConnector
-          .resolveDid(address)
-          .catch(err => {
-            console.error({ error: err });
-            return null;
-          });
+    if (!lastUsedConnector) {
+      console.warn({
+        message: `The connector for wallet name: ${lastUsedConnectorName} was not found in the list of connectors`,
+      });
+      return;
+    }
 
-        this.setDid(did);
+    this.store.setActiveConnector(lastUsedConnector);
 
-        const chain = this.activeConnector.getChainId
-          ? await this.activeConnector.getChainId()
-          : null;
+    const activeConnector = this.store.getActiveConnector();
 
-        this.setChainId(chain);
+    if (activeConnector) {
+      this.emitter.emit(
+        "isAutoConnecting",
+        activeConnector.ecosystem,
+        activeConnector
+      );
 
-        this.setActiveChain(this.activeConnector.activeChain);
-        this.setIsAutoConnecting(false);
-        this.setIsConnected(true);
-      } else {
-        this.setIsAutoConnecting(false);
-      }
-    } catch (error) {
-      console.error({ error });
-      this.setIsAutoConnecting(false);
+      await activeConnector.connect();
     }
   }
 }

src/client/store.ts

@@ -1,11 +0,27 @@
-import getState from "../store/rootStore";
+import { getState } from "../store/rootStore";
+import { IState } from "../store/storeTypes";
 import { BaseConnector } from "../types";
 
 export class Wallet01Store {
-  getActiveChain(): "ethereum" | "solana" | "cosmos" | "tezos" | null {
-    const { activeChain } = getState();
-    return activeChain;
+  static #instance: Wallet01Store;
+
+  private constructor() {
+    this.getState = getState;
   }
 
-  getAddress(): string | null {
+  public static init() {
+    if (!Wallet01Store.#instance) {
+      Wallet01Store.#instance = new Wallet01Store();
+    }
+    return Wallet01Store.#instance;
+  }
+
+  getState: () => IState;
+
+  getEcosystem() {
+    const { ecosystem } = getState();
+    return ecosystem;
+  }
+
+  getAddress() {
     const { address } = getState();
@@ -15,5 +31,5 @@ return address;
 
-  getDid(): string | null {
-    const { did } = getState();
-    return did;
+  getAddresses() {
+    const { addresses } = getState();
+    return addresses;
   }
@@ -31,7 +47,2 @@
 
-  getAutoConnect(): boolean {
-    const { autoConnect } = getState();
-    return autoConnect;
-  }
-
   getConnectors(): BaseConnector[] {
@@ -47,20 +58,8 @@ const { connectors } = getState();
 
-  getLastUsedConnector(): BaseConnector | null {
-    const { lastUsedConnector } = getState();
-    return lastUsedConnector;
+  setEcosystem(ecosystem: "ethereum" | "solana" | "cosmos" | "tezos" | null) {
+    const { setEcosystem } = getState();
+    setEcosystem(ecosystem);
   }
 
-  getIsAutoConnecting(): boolean {
-    const { isAutoConnecting } = getState();
-    return isAutoConnecting;
-  }
-
-  setActiveChain(
-    activeChain: "ethereum" | "solana" | "cosmos" | "tezos" | null
-  ): void {
-    const { setActiveChain } = getState();
-    setActiveChain(activeChain);
-  }
-
-  setAddress(address: string | null): void {
+  setAddress(address: string | null) {
     const { setAddress } = getState();
@@ -70,8 +69,8 @@ setAddress(address);
 
-  setDid(did: string | null): void {
-    const { setDid } = getState();
-    setDid(did);
+  setAddresses(addresses: string[]) {
+    const { setAddresses } = getState();
+    setAddresses(addresses);
   }
 
-  setIsConnected(val: boolean): void {
+  setIsConnected(val: boolean) {
     const { setIsConnected } = getState();
@@ -81,3 +80,3 @@ setIsConnected(val);
 
-  setChainId(id: string | null): void {
+  setChainId(id: string | "mainnet" | null) {
     const { setChainId } = getState();
@@ -87,8 +86,3 @@ setChainId(id);
 
-  setAutoConnect(val: boolean): void {
-    const { setAutoConnect } = getState();
-    setAutoConnect(val);
-  }
-
-  setConnectors(connectors: BaseConnector[]): void {
+  setConnectors(connectors: BaseConnector[]) {
     const { setConnectors } = getState();
@@ -98,16 +92,6 @@ setConnectors(connectors);
 
-  setActiveConnector(connector: BaseConnector | null): void {
+  setActiveConnector(connector: BaseConnector | null) {
     const { setActiveConnector } = getState();
     setActiveConnector(connector);
   }
-
-  setLastUsedConnector(connector: BaseConnector | null): void {
-    const { setLastUsedConnector } = getState();
-    setLastUsedConnector(connector);
-  }
-
-  setIsAutoConnecting(val: boolean): void {
-    const { setIsAutoConnecting } = getState();
-    setIsAutoConnecting(val);
-  }
 }

src/index.ts

 // import { Client, createClient } from './client';
 import Client from "./client/client";
-import { useStore } from "./store/rootStore";
+import { useStore, getState, setState } from "./store/rootStore";
 
-import {
-  type ClientConfig,
-  type ConnectedData,
-  BaseConnector,
-  TProvider,
-} from "./types";
+import { BaseConnector } from "./types/BaseConnector";
 
-import setLastUsedConnector from "./utils/util";
+import setLastUsedConnector from "./utils";
 
-export {
-  Client,
-  type ClientConfig,
-  type ConnectedData,
-  type TProvider,
-  BaseConnector,
-  setLastUsedConnector,
-  useStore,
-};
+export { Client, BaseConnector, setLastUsedConnector };
+
+export { useStore, getState, setState };
+
+export * from "./utils/errors";

src/store/createAccountSlice.ts

@@ -1,3 +0,3 @@
-import { StateCreator } from 'zustand';
-import { IAccountState } from './storeTypes';
+import { StateCreator } from "zustand";
+import { IAccountState } from "./storeTypes";
 
@@ -11,8 +11,8 @@ const createAccountSlice: StateCreator<
   address: null,
-  did: null,
+  addresses: [],
   setAddress: address => {
     set(() => ({ address }));
   },
-  setDid: did => {
-    set(() => ({ did }));
+  setAddresses: addresses => {
+    set(() => ({ addresses }));
   },
@@ -19,0 +19,0 @@ });

src/store/createClientSlice.ts

@@ -10,14 +10,8 @@ import { StateCreator } from "zustand";
 > = set => ({
-  activeChain: null,
-  autoConnect: false,
+  ecosystem: null,
   connectors: [],
   activeConnector: null,
-  lastUsedConnector: null,
-  isAutoConnecting: true,
-  setActiveChain: activeChain => {
-    set(() => ({ activeChain }));
+  setEcosystem: ecosystem => {
+    set(() => ({ ecosystem }));
   },
-  setAutoConnect: autoConnect => {
-    set(() => ({ autoConnect }));
-  },
   setConnectors: connectors => {
@@ -29,10 +23,4 @@ set(() => ({ connectors }));
   },
-  setLastUsedConnector: lastUsedConnector => {
-    set(() => ({ lastUsedConnector }));
-  },
-  setIsAutoConnecting: val => {
-    set(() => ({ isAutoConnecting: val }));
-  },
 });
 
 export default createClientSlice;

src/store/createWalletSlice.ts

@@ -1,3 +0,3 @@
-import { StateCreator } from 'zustand';
-import { IWalletState } from './storeTypes';
+import { StateCreator } from "zustand";
+import { IWalletState } from "./storeTypes";
 
@@ -11,3 +11,3 @@ const createWalletSlice: StateCreator<
   isConnected: false,
-  chainId: null,
+  chainId: "mainnet",
   setIsConnected: isConnected => {
@@ -14,0 +14,0 @@ set(() => ({ isConnected }));

src/store/rootStore.ts

@@ -1,6 +0,6 @@
-import create from 'zustand';
-import createAccountSlice from './createAccountSlice';
-import createClientSlice from './createClientSlice';
-import createWalletSlice from './createWalletSlice';
-import { IState } from './storeTypes';
+import create from "zustand";
+import createAccountSlice from "./createAccountSlice";
+import createClientSlice from "./createClientSlice";
+import createWalletSlice from "./createWalletSlice";
+import { IState } from "./storeTypes";
 
@@ -13,4 +13,4 @@ export const useStore = create<IState>()((...a) => ({
 
-const { getState } = useStore;
+export const { getState, setState } = useStore;
 
-export default getState;
+// export default getState;

src/store/storeTypes.ts

 import { BaseConnector } from "../types";
 
+export type TEcosystem = "ethereum" | "solana" | "cosmos" | "tezos";
+
 export interface IAccountState {
   address: string | null;
-  did: string | null;
+  addresses: string[];
   setAddress: (address: string | null) => void;
-  setDid: (did: string | null) => void;
+  setAddresses: (addresses: string[]) => void;
 }
@@ -12,24 +14,16 @@
   isConnected: boolean;
-  chainId: string | null;
+  chainId: "mainnet" | string | null;
   setIsConnected: (val: boolean) => void;
-  setChainId: (id: string | null) => void;
+  setChainId: (id: "mainnet" | string | null) => void;
 }
 
 export interface IClientState {
-  activeChain: "ethereum" | "solana" | "cosmos" | "tezos" | null;
-  autoConnect: boolean;
+  ecosystem: TEcosystem | null;
   connectors: BaseConnector[];
   activeConnector: BaseConnector | null;
-  lastUsedConnector: BaseConnector | null;
-  isAutoConnecting: boolean;
-  setActiveChain: (
-    val: "ethereum" | "solana" | "cosmos" | "tezos" | null
-  ) => void;
-  setAutoConnect: (val: boolean) => void;
+  setEcosystem: (val: TEcosystem | null) => void;
   setConnectors: (connectors: BaseConnector[]) => void;
   setActiveConnector: (connector: BaseConnector | null) => void;
-  setLastUsedConnector: (connector: BaseConnector | null) => void;
-  setIsAutoConnecting: (val: boolean) => void;
 }
 
 export type IState = IAccountState & IWalletState & IClientState;

src/types/index.ts

@@ -1,15 +0,3 @@
-import { BaseConnector } from './baseConnector';
-import { TProvider } from './TProvider';
+import { BaseConnector } from "./BaseConnector";
 
-type ClientConfig<TProvider> = {
-  chainId: string;
-  connector: BaseConnector<TProvider>;
-};
-
-type ConnectedData<TProvider> = {
-  account: string;
-  chainId: string;
-  provider: TProvider;
-};
-
-export { type ClientConfig, type ConnectedData, BaseConnector, type TProvider };
+export { BaseConnector };

tsup.config.ts

@@ -13,3 +13,3 @@ import { defineConfig } from "tsup";
   outDir: "dist",
-  entry: ["src/**/*.ts"], //include all files under src
+  entry: ["src/index.ts"],
 });

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

68854

increased by31.18%

Lines of code

1685

increased by40.77%

Worsened metrics

Number of package files

54

decreased by-37.93%

Number of medium supply chain risk alerts

2

increased byInfinity%

No dependency changes