@rango-dev/wallets-core 0.38.0 → 0.38.1-next.0

package/src/namespaces/evm/mod.ts

@@ -0,0 +1,9 @@
+export * as actions from './actions.js';
+export * as after from './after.js';
+export * as and from './and.js';
+export * as before from './before.js';
+export * as utils from './utils.js';
+export * as builders from './builders.js';
+
+export type { EvmActions, ProviderAPI } from './types.js';
+export { CAIP_NAMESPACE, CAIP_ETHEREUM_CHAIN_ID } from './constants.js';

package/src/namespaces/evm/types.ts

@@ -0,0 +1,18 @@
+import type { AddEthereumChainParameter } from './eip1193.js';
+import type { AccountsWithActiveChain } from '../../types/accounts.js';
+import type {
+  AutoImplementedActionsByRecommended,
+  CommonActions,
+} from '../common/types.js';
+
+export interface EvmActions
+  extends AutoImplementedActionsByRecommended,
+    CommonActions {
+  connect: (chain?: Chain | ChainId) => Promise<AccountsWithActiveChain>;
+}
+
+export type { EIP1193Provider as ProviderAPI } from './eip1193.js';
+
+// A 0x-prefixed hexadecimal string
+export type ChainId = string;
+export type Chain = AddEthereumChainParameter;

package/src/namespaces/evm/utils.ts

@@ -0,0 +1,52 @@
+import type { Chain, ChainId, ProviderAPI } from './types.js';
+
+export async function getAccounts(provider: ProviderAPI) {
+  const [accounts, chainId] = await Promise.all([
+    provider.request({ method: 'eth_requestAccounts' }),
+    provider.request({ method: 'eth_chainId' }),
+  ]);
+
+  return {
+    accounts,
+    chainId,
+  };
+}
+
+export async function suggestNetwork(instance: ProviderAPI, chain: Chain) {
+  return await instance.request({
+    method: 'wallet_addEthereumChain',
+    params: [chain],
+  });
+}
+
+export async function switchNetwork(instance: ProviderAPI, chainId: ChainId) {
+  return await instance.request({
+    method: 'wallet_switchEthereumChain',
+    params: [{ chainId: chainId }],
+  });
+}
+
+export async function switchOrAddNetwork(
+  instance: ProviderAPI,
+  chain: ChainId | Chain
+) {
+  try {
+    const chainId = typeof chain === 'string' ? chain : chain.chainId;
+    await switchNetwork(instance, chainId);
+  } catch (switchError) {
+    const error = switchError as { code: number };
+
+    const NOT_FOUND_CHAIN_ERROR_CODE = 4902;
+    if (
+      typeof chain !== 'string' &&
+      (error.code === NOT_FOUND_CHAIN_ERROR_CODE || !error.code)
+    ) {
+      /*
+       * Note: on WalletConnect `code` is undefined so we have to use !switchError.code as fallback.
+       * This error code indicates that the chain has not been added to wallet.
+       */
+      await suggestNetwork(instance, chain);
+    }
+    throw switchError;
+  }
+}

package/src/namespaces/solana/actions.ts

@@ -0,0 +1,70 @@
+import type { ProviderAPI, SolanaActions } from './types.js';
+import type { Subscriber } from '../../hub/namespaces/mod.js';
+import type { SubscriberCleanUp } from '../../hub/namespaces/types.js';
+import type { AnyFunction } from '../../types/actions.js';
+
+import { AccountId } from 'caip';
+
+import { recommended as commonRecommended } from '../common/actions.js';
+
+import { CAIP_NAMESPACE, CAIP_SOLANA_CHAIN_ID } from './constants.js';
+
+export const recommended = [...commonRecommended];
+
+export function changeAccountSubscriber(
+  instance: () => ProviderAPI | undefined
+): [Subscriber<SolanaActions>, SubscriberCleanUp<SolanaActions>] {
+  let eventCallback: AnyFunction;
+
+  // subscriber can be passed to `or`, it will get the error and should rethrow error to pass the error to next `or` or throw error.
+  return [
+    (context, err) => {
+      const solanaInstance = instance();
+
+      if (!solanaInstance) {
+        throw new Error(
+          'Trying to subscribe to your Solana wallet, but seems its instance is not available.'
+        );
+      }
+
+      const [, setState] = context.state();
+
+      eventCallback = (publicKey) => {
+        /*
+         * In Phantom, when user is switching to an account which is not connected to dApp yet, it returns a null.
+         * So null means we don't have access to account and we 0 need to disconnect and let the user connect the account.
+         */
+        if (!publicKey) {
+          context.action('disconnect');
+          return;
+        }
+
+        setState('accounts', [
+          AccountId.format({
+            address: publicKey.toString(),
+            chainId: {
+              namespace: CAIP_NAMESPACE,
+              reference: CAIP_SOLANA_CHAIN_ID,
+            },
+          }),
+        ]);
+      };
+      solanaInstance.on('accountChanged', eventCallback);
+
+      if (err instanceof Error) {
+        throw err;
+      }
+    },
+    (_context, err) => {
+      const solanaInstance = instance();
+
+      if (eventCallback && solanaInstance) {
+        solanaInstance.off('accountChanged', eventCallback);
+      }
+
+      if (err instanceof Error) {
+        throw err;
+      }
+    },
+  ];
+}

package/src/namespaces/solana/after.ts

@@ -0,0 +1,3 @@
+import { recommended as commonRecommended } from '../common/after.js';
+
+export const recommended = [...commonRecommended];

package/src/namespaces/solana/and.ts

@@ -0,0 +1,5 @@
+import { connectAndUpdateStateForSingleNetwork } from '../common/mod.js';
+
+export const recommended = [
+  ['connect', connectAndUpdateStateForSingleNetwork] as const,
+];

package/src/namespaces/solana/before.ts

@@ -0,0 +1,3 @@
+import { recommended as commonRecommended } from '../common/before.js';
+
+export const recommended = [...commonRecommended];

package/src/namespaces/solana/builders.ts

@@ -0,0 +1,10 @@
+import type { SolanaActions } from './types.js';
+
+import { ActionBuilder } from '../../mod.js';
+import { intoConnectionFinished } from '../common/after.js';
+import { connectAndUpdateStateForSingleNetwork } from '../common/and.js';
+
+export const connect = () =>
+  new ActionBuilder<SolanaActions, 'connect'>('connect')
+    .and(connectAndUpdateStateForSingleNetwork)
+    .after(intoConnectionFinished);

package/src/namespaces/solana/constants.ts

@@ -0,0 +1,2 @@
+export const CAIP_NAMESPACE = 'solana';
+export const CAIP_SOLANA_CHAIN_ID = '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp';

package/src/namespaces/solana/mod.ts

@@ -0,0 +1,8 @@
+export * as actions from './actions.js';
+export * as after from './after.js';
+export * as and from './and.js';
+export * as before from './before.js';
+export * as builders from './builders.js';
+
+export type { ProviderAPI, SolanaActions } from './types.js';
+export { CAIP_NAMESPACE, CAIP_SOLANA_CHAIN_ID } from './constants.js';

package/src/namespaces/solana/types.ts

@@ -0,0 +1,20 @@
+import type { Accounts } from '../../types/accounts.js';
+import type {
+  AutoImplementedActionsByRecommended,
+  CommonActions,
+} from '../common/types.js';
+
+export interface SolanaActions
+  extends AutoImplementedActionsByRecommended,
+    CommonActions {
+  connect: () => Promise<Accounts>;
+}
+
+/*
+ *
+ * TODO: That would be better to define a type for Solana injected wallets.
+ * They have something called [Wallet Standard](https://github.com/wallet-standard/wallet-standard) but not sure all the Solana wallets support that (Phantom do).
+ * If Phantom's interface is what Solana wallets are supporting, another option would be define that type here.
+ *
+ */
+export type ProviderAPI = Record<string, any>;

package/src/test-utils/fixtures.ts

@@ -0,0 +1,9 @@
+import type { ProviderConfig } from '../hub/store/mod.js';
+
+export const garbageWalletInfo: ProviderConfig['info'] = {
+  name: 'Garbage Wallet',
+  icon: 'https://somewhereininternet.com/icon.svg',
+  extensions: {
+    homepage: 'https://app.rango.exchange',
+  },
+};

package/src/types/accounts.ts

@@ -0,0 +1,12 @@
+type CaipNamespace = string;
+type CaipChainId = string;
+type CaipAccountAddress = string;
+
+export type CaipAccount =
+  `${CaipNamespace}:${CaipChainId}:${CaipAccountAddress}`;
+
+export type Accounts = CaipAccount[];
+export type AccountsWithActiveChain = {
+  accounts: Accounts;
+  network: string;
+};

package/src/types/actions.ts

@@ -0,0 +1,11 @@
+export type AnyFunction = (...args: any[]) => any;
+export type AnyPromiseFunction = (...args: any[]) => Promise<any>;
+
+export type AndFunction<
+  T extends Record<string, AnyPromiseFunction>,
+  K extends keyof T
+> = (result: Awaited<ReturnType<T[K]>>) => Awaited<ReturnType<T[K]>>;
+
+export type FunctionWithContext<T, C> = T extends (...args: infer P) => infer R
+  ? (context: C, ...args: P) => R
+  : never;

package/src/types/utils.ts

@@ -0,0 +1,7 @@
+/**
+ * @see https://x.com/mattpocockuk/status/1622730173446557697
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+  // eslint-disable-next-line @typescript-eslint/ban-types
+} & {};

package/src/utils/mod.ts

@@ -0,0 +1,8 @@
+/*
+ * It is not a good idea to re-export all of CAIP because if they have a breaking change, we will break as well.
+ * It would be better to create an abstraction over them and export our own interface to ensure it is under our control.
+ */
+export * as CAIP from 'caip';
+
+export { generateStoreId } from '../hub/helpers.js';
+export * from './versions.js';

package/src/utils/versions.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from 'vitest';
+
+import { defineVersions, pickVersion } from './versions.js';
+
+describe('Picking versions should work correctly', () => {
+  test("Error on picking a version doesn't exist", () => {
+    const versions = defineVersions().build();
+    // const versions: Versions = [['1.0.0', {}]];
+    expect(() => pickVersion(versions, '1.0.0')).toThrowError();
+  });
+
+  test('Pick the correct version if it exist', () => {
+    const versions = defineVersions()
+      .version('0.0.0', {} as any)
+      .version('1.0.0', {} as any)
+      .build();
+
+    const target = pickVersion(versions, '1.0.0');
+    expect(target).toBeDefined();
+    expect(target[0]).toBe('1.0.0');
+  });
+});

package/src/utils/versions.ts

@@ -0,0 +1,63 @@
+import type { Provider } from '../hub/mod.js';
+import type { LegacyProviderInterface } from '../legacy/mod.js';
+
+type VersionedVLegacy = ['0.0.0', LegacyProviderInterface];
+type VersionedV1 = ['1.0.0', Provider];
+type AvailableVersions = VersionedVLegacy | VersionedV1;
+export type Versions = AvailableVersions[];
+// eslint-disable-next-line @typescript-eslint/no-magic-numbers
+export type VersionInterface<T extends AvailableVersions[]> = T[1];
+
+type SemVer<T extends [string, any]> = T extends [infer U, any] ? U : never;
+type MatchVersion<T extends Versions, Version> = Extract<
+  T[number],
+  [Version, any]
+>;
+
+export function pickVersion<
+  L extends Versions,
+  V extends SemVer<Versions[number]>
+>(list: L, targetVersion: V): MatchVersion<L, V> {
+  if (!targetVersion) {
+    throw new Error(`You should provide a valid semver, e.g 1.0.0.`);
+  }
+
+  const target = list.find(([version]) => version === targetVersion);
+
+  if (!target) {
+    throw new Error(
+      `You target version hasn't been found. Available versions: ${Object.keys(
+        list
+      ).join(', ')}`
+    );
+  }
+  return target as MatchVersion<L, V>;
+}
+
+interface DefineVersionsApi {
+  version: <T extends SemVer<Versions[number]>>(
+    semver: T,
+    value: VersionInterface<MatchVersion<Versions, T>>
+  ) => DefineVersionsApi;
+  build: () => Versions;
+}
+
+export function defineVersions(): DefineVersionsApi {
+  const versions: Versions = [];
+  const api: DefineVersionsApi = {
+    version: (semver, value) => {
+      versions.push([semver, value]);
+      return api;
+    },
+    build: () => {
+      return versions;
+    },
+  };
+  return api;
+}
+
+export function legacyProviderImportsToVersionsInterface(
+  provider: LegacyProviderInterface
+): Versions {
+  return defineVersions().version('0.0.0', provider).build();
+}