@rango-dev/wallets-core 0.0.0-experimental-936229e8-20251208

package/src/builders/provider.ts

@@ -0,0 +1,61 @@
+import type { FindProxiedNamespace } from './types.js';
+import type {
+  CommonNamespaces,
+  ExtendableInternalActions,
+  ProviderBuilderOptions,
+} from '../hub/provider/mod.js';
+import type { ProviderConfig } from '../hub/store/mod.js';
+
+import { Provider } from '../hub/provider/mod.js';
+
+export class ProviderBuilder {
+  #id: string;
+  #namespaces = new Map();
+  #methods: ExtendableInternalActions = {};
+  #configs: Partial<ProviderConfig> = {};
+  #options: Partial<ProviderBuilderOptions>;
+
+  constructor(id: string, options?: ProviderBuilderOptions) {
+    this.#id = id;
+    this.#options = options || {};
+  }
+
+  public add<K extends keyof CommonNamespaces>(
+    id: K,
+    namespace: FindProxiedNamespace<K, CommonNamespaces>
+  ) {
+    if (this.#options.store) {
+      namespace.store(this.#options.store);
+    }
+    this.#namespaces.set(id, namespace);
+    return this;
+  }
+
+  public config<K extends keyof ProviderConfig>(
+    name: K,
+    value: ProviderConfig[K]
+  ) {
+    this.#configs[name] = value;
+    return this;
+  }
+
+  public init(cb: Exclude<ExtendableInternalActions['init'], undefined>) {
+    this.#methods.init = cb;
+    return this;
+  }
+
+  public build(): Provider {
+    if (this.#isConfigsValid(this.#configs)) {
+      return new Provider(this.#id, this.#namespaces, this.#configs, {
+        extendInternalActions: this.#methods,
+        store: this.#options.store,
+      });
+    }
+
+    throw new Error('You need to set all required configs.');
+  }
+
+  #isConfigsValid(config: Partial<ProviderConfig>): config is ProviderConfig {
+    return !!config.metadata;
+  }
+}

package/src/builders/types.ts

@@ -0,0 +1,29 @@
+import type { allowedMethods } from './namespace.js';
+import type { Actions, Namespace } from '../hub/namespaces/mod.js';
+
+// These should be matched with `/hub/namespace.ts` public values.
+type NamespacePublicValues = {
+  namespaceId: string;
+  providerId: string;
+};
+
+/**
+ * NamespaceBuilder is creating a proxy instead of return Namespace instance.
+ * The reason is improving access to actions. e.g `.connect()` instead of `.run('connect')`
+ */
+export type ProxiedNamespace<T extends Actions<T>> = T &
+  Pick<Namespace<T>, (typeof allowedMethods)[number]> &
+  NamespacePublicValues;
+
+/**
+ * This is useful when you gave a list of namespaces and want to map a key to corresponding namespace.
+ *
+ * e.g:
+ * Type List = { evm: EvmActions, solana: SolanaActions};
+ * FindProxiedNamespace<"solana", List>
+ */
+export type FindProxiedNamespace<K extends keyof T, T> = T[K] extends Actions<
+  T[K]
+>
+  ? ProxiedNamespace<T[K]>
+  : never;

package/src/hub/helpers.ts

@@ -0,0 +1,11 @@
+/**
+ * Note: This only works native async, if we are going to support for old transpilers like Babel.
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function isAsync(fn: Function) {
+  return fn.constructor.name === 'AsyncFunction';
+}
+
+export function generateStoreId(providerId: string, namespace: string) {
+  return `${providerId}$$${namespace}`;
+}

package/src/hub/hub.ts

@@ -0,0 +1,128 @@
+import type { Namespace, State as NamespaceState } from './namespaces/mod.js';
+import type { Provider, State as ProviderState } from './provider/mod.js';
+import type { Store } from './store/mod.js';
+
+type HubState = {
+  [key in string]: ProviderState & {
+    namespaces: NamespaceState[];
+  };
+};
+
+type RunAllResult = {
+  id: string;
+  provider: unknown;
+  namespaces: unknown[];
+};
+
+interface HubOptions {
+  store?: Store;
+}
+export class Hub {
+  #providers = new Map<string, Provider>();
+  #options: HubOptions;
+
+  constructor(options?: HubOptions) {
+    this.#options = options ?? {};
+  }
+
+  init() {
+    this.runAll('init');
+  }
+
+  /*
+   * Running a specific action (e.g. init) on all namespaces and providers one by one.
+   *
+   *  TODO: Some of methods may accepts args, with this implementation we only limit to those one without any argument.
+   */
+  runAll(action: string): RunAllResult[] {
+    const output: RunAllResult[] = [];
+
+    // run action on all providers eagerConnect, disconnect
+    const providers = this.#providers.values();
+
+    for (const provider of providers) {
+      // Calling `action` on `Provider` if exists.
+      const providerOutput: RunAllResult = {
+        id: provider.id,
+        provider: undefined,
+        namespaces: [],
+      };
+
+      const providerMethod = provider[action as keyof Provider];
+      if (typeof providerMethod === 'function') {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore-next-line
+        providerOutput.provider = providerMethod.call(provider);
+      }
+
+      // Namespace instances can have their own `action` as well. we will call them as well.
+      const namespaces = provider.getAll().values();
+      for (const namespace of namespaces) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore-next-line
+        const namespaceMethod = namespace[action];
+        if (typeof namespaceMethod === 'function') {
+          const result = namespaceMethod();
+          providerOutput.namespaces.push(result);
+        }
+      }
+
+      output.push(providerOutput);
+    }
+
+    return output;
+  }
+
+  add(id: string, provider: Provider) {
+    if (this.#options.store) {
+      provider.store(this.#options.store);
+    }
+    this.#providers.set(id, provider);
+    return this;
+  }
+  remove(id: string) {
+    const providerToRemove = this.#providers.get(id);
+
+    if (!providerToRemove) {
+      throw new Error(`Provider not found: No provider exists with ID "${id}"`);
+    }
+
+    this.#options.store?.getState().providers.removeProvider(id);
+    this.#providers.delete(id);
+
+    return this;
+  }
+
+  get(providerId: string): Provider | undefined {
+    return this.#providers.get(providerId);
+  }
+
+  getAll() {
+    return this.#providers;
+  }
+
+  state(): HubState {
+    const output = this.runAll('state');
+    const res: HubState = {};
+
+    output.forEach((result) => {
+      const namespaces: NamespaceState[] = [];
+      result.namespaces.forEach((b) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const [getNamespaceState] = b as ReturnType<Namespace<any>['state']>;
+
+        namespaces.push(getNamespaceState());
+      });
+
+      const [getProviderState] = result.provider as ReturnType<
+        Provider['state']
+      >;
+
+      res[result.id] = {
+        ...(getProviderState() || {}),
+        namespaces: namespaces,
+      };
+    });
+    return res;
+  }
+}

package/src/hub/mod.ts

@@ -0,0 +1,18 @@
+export type {
+  Subscriber,
+  SubscriberCleanUp,
+  Context,
+} from './namespaces/mod.js';
+export { Namespace } from './namespaces/mod.js';
+
+export { Provider } from './provider/mod.js';
+export type { CommonNamespaces, CommonNamespaceKeys } from './provider/mod.js';
+
+export { Hub } from './hub.js';
+export type { Store, State, ProviderMetadata } from './store/mod.js';
+export {
+  createStore,
+  guessProviderStateSelector,
+  namespaceStateSelector,
+} from './store/mod.js';
+export { generateStoreId } from './helpers.js';

package/src/hub/namespaces/errors.ts

@@ -0,0 +1,11 @@
+export const ACTION_NOT_FOUND_ERROR = (name: string) =>
+  `Couldn't find "${name}" action. Are you sure you've added the action?`;
+
+export const OR_ELSE_ACTION_FAILED_ERROR = (name: string) =>
+  `An error occurred during running ${name}`;
+
+export const BEFORE_ACTION_FAILED_ERROR = (name: string) =>
+  `An error occurred during running before for "${name}" action`;
+
+export const NO_STORE_FOUND_ERROR =
+  'For setup store, you should set `store` first.';

package/src/hub/namespaces/mod.ts

@@ -0,0 +1,10 @@
+export type {
+  Subscriber,
+  SubscriberCleanUp,
+  State,
+  RegisteredActions as ActionsMap,
+  Context,
+  Actions,
+} from './types.js';
+
+export { Namespace } from './namespace.js';