@rango-dev/provider-walletconnect-2 0.57.0 → 0.57.1-next.0

package/src/session/proposals.ts

@@ -0,0 +1,96 @@
+import type { WalletConnectNamespace } from '../types.js';
+import type { ChainIdParams } from 'caip';
+
+import { CAIP_BITCOIN_CHAIN_ID } from '@rango-dev/wallets-core/namespaces/utxo';
+import { ChainId } from 'caip';
+
+import {
+  DEFAULT_BITCOIN_EVENTS,
+  DEFAULT_BITCOIN_METHODS,
+  DEFAULT_ETHEREUM_EVENTS,
+  DEFAULT_ETHEREUM_METHODS,
+  NAMESPACES,
+  WC_NAMESPACE_TO_CAIP,
+} from '../wcConstants.js';
+
+/**
+ * `chains` is required here so the same shape is assignable both to the
+ * SignClient `ProposalTypes` (chains optional) and to the UniversalProvider
+ * `NamespaceConfig` (chains required).
+ */
+export type FinalNamespaces = Record<
+  string,
+  { chains: string[]; methods: string[]; events: string[] }
+>;
+
+type NamespaceProposal = {
+  methods: string[];
+  events: string[];
+  resolveChains: (
+    chains: ChainIdParams[],
+    targetChainReference?: string
+  ) => ChainIdParams[];
+};
+
+/**
+ * Per-namespace proposal facts as data, keyed by `WalletConnectNamespace` so a
+ * newly-added alias is a compile error until it's configured here. The CAIP
+ * prefix comes from the shared `WC_NAMESPACE_TO_CAIP` map.
+ */
+const NAMESPACE_PROPOSALS: Record<WalletConnectNamespace, NamespaceProposal> = {
+  evm: {
+    methods: DEFAULT_ETHEREUM_METHODS,
+    events: DEFAULT_ETHEREUM_EVENTS,
+    resolveChains: (chains, targetChainReference) => {
+      if (targetChainReference) {
+        return [
+          { namespace: NAMESPACES.ETHEREUM, reference: targetChainReference },
+        ];
+      }
+      return chains.length > 0
+        ? chains
+        : [{ namespace: NAMESPACES.ETHEREUM, reference: '1' }];
+    },
+  },
+  utxo: {
+    methods: DEFAULT_BITCOIN_METHODS,
+    events: DEFAULT_BITCOIN_EVENTS,
+    resolveChains: () => [
+      { namespace: NAMESPACES.BITCOIN, reference: CAIP_BITCOIN_CHAIN_ID },
+    ],
+  },
+};
+
+/**
+ * Builds a WalletConnect namespace proposal (chains, methods, events).
+ *
+ * The result always goes to `optionalNamespaces`: sign-client merges
+ * `requiredNamespaces` into `optionalNamespaces` and clears it before sending
+ * the proposal, so passing anything as required only earns a deprecation
+ * warning. Narrowing the proposal (see `targetChainReference`) is what actually
+ * constrains what the wallet can approve.
+ *
+ * @param targetChainReference - When set for EVM, limits the proposal to this
+ *   single chain id (decimal string, e.g. `"137"`). Omit to include all EVM
+ *   chains from `chains`.
+ */
+export function generateOptionalNamespace(
+  chains: ChainIdParams[],
+  namespaces: WalletConnectNamespace[],
+  targetChainReference?: string
+): FinalNamespaces | undefined {
+  const proposal: FinalNamespaces = {};
+
+  for (const namespace of namespaces) {
+    const config = NAMESPACE_PROPOSALS[namespace];
+    proposal[WC_NAMESPACE_TO_CAIP[namespace]] = {
+      methods: config.methods,
+      events: config.events,
+      chains: config
+        .resolveChains(chains, targetChainReference)
+        .map((chain) => new ChainId(chain).toString()),
+    };
+  }
+
+  return Object.keys(proposal).length > 0 ? proposal : undefined;
+}

package/src/session/restore-cache.ts

@@ -0,0 +1,38 @@
+import type { SessionCache } from '../adapter/session-cache.js';
+import type { SignClientInstance, WalletConnectNamespace } from '../types.js';
+import type { SessionTypes } from '@walletconnect/types';
+
+import { debug } from '@rango-dev/logging-core';
+
+import {
+  restoreWalletConnectSession,
+  type RestoreWalletConnectSessionOptions,
+} from './lifecycle.js';
+
+export async function restoreAndCacheSession(
+  client: SignClientInstance,
+  namespace: WalletConnectNamespace,
+  cache: SessionCache,
+  options?: RestoreWalletConnectSessionOptions,
+  onDisconnect?: (namespace: WalletConnectNamespace) => Promise<void>
+): Promise<SessionTypes.Struct | null> {
+  try {
+    const session = await restoreWalletConnectSession(
+      client,
+      namespace,
+      options
+    );
+    if (!session) {
+      return null;
+    }
+
+    cache.set(namespace, session);
+    return session;
+  } catch (error) {
+    debug(error instanceof Error ? error : new Error(String(error)));
+    if (cache.get(namespace)) {
+      await onDisconnect?.(namespace);
+    }
+    return null;
+  }
+}

package/src/session/teardown.ts

@@ -0,0 +1,181 @@
+import type { SignClientInstance, WalletConnectNamespace } from '../types.js';
+import type { ISignClient, SessionTypes } from '@walletconnect/types';
+import type UniversalProvider from '@walletconnect/universal-provider';
+
+import { debug } from '@rango-dev/logging-core';
+import { getSdkError } from '@walletconnect/utils';
+
+import { NAMESPACES } from '../wcConstants.js';
+
+import { persistCurrentChainId } from './chain-state.js';
+import { getSessionNamespace } from './lookup.js';
+
+function isNoMatchingKeyError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes('No matching key');
+}
+
+export function hasActiveSession(client: ISignClient, topic: string): boolean {
+  try {
+    return !!client.session.get(topic);
+  } catch {
+    return false;
+  }
+}
+
+export function hasActivePairing(
+  client: SignClientInstance,
+  topic: string
+): boolean {
+  return client.pairing.getAll().some((pairing) => pairing.topic === topic);
+}
+
+export async function expireWalletConnectTopic(
+  client: SignClientInstance,
+  topic: string
+) {
+  const sessions = client.session.getAll();
+  const pairings = client.pairing.getAll();
+
+  sessions.forEach((session: SessionTypes.Struct) => {
+    if (session.topic === topic || session.pairingTopic === topic) {
+      const requestForDeleteTopic =
+        session.pairingTopic === topic ? session.pairingTopic : session.topic;
+      client.core.expirer.set(requestForDeleteTopic, 0);
+    }
+  });
+
+  pairings.forEach((pairing) => {
+    if (pairing.topic === topic) {
+      client.core.expirer.set(topic, 0);
+    }
+  });
+}
+
+export async function removeSessionRecord(
+  client: SignClientInstance,
+  session: SessionTypes.Struct
+) {
+  const namespace = getSessionNamespace(session);
+  const pairingTopic = session.pairingTopic;
+
+  if (hasActiveSession(client, session.topic)) {
+    try {
+      await client.disconnect({
+        topic: session.topic,
+        reason: getSdkError('USER_DISCONNECTED'),
+      });
+    } catch (error) {
+      debug(error instanceof Error ? error : new Error(String(error)));
+      if (isNoMatchingKeyError(error)) {
+        await expireWalletConnectTopic(client, session.topic);
+      }
+    }
+  } else {
+    await expireWalletConnectTopic(client, session.topic);
+  }
+
+  const remainingOnPairing = client.session
+    .getAll()
+    .filter((item) => item.pairingTopic === pairingTopic);
+
+  if (!remainingOnPairing.length && pairingTopic) {
+    if (hasActivePairing(client, pairingTopic)) {
+      try {
+        await client.disconnect({
+          topic: pairingTopic,
+          reason: getSdkError('USER_DISCONNECTED'),
+        });
+      } catch (error) {
+        debug(error instanceof Error ? error : new Error(String(error)));
+        if (isNoMatchingKeyError(error)) {
+          await expireWalletConnectTopic(client, pairingTopic);
+        }
+      }
+    } else {
+      await expireWalletConnectTopic(client, pairingTopic);
+    }
+  }
+
+  if (namespace === 'evm') {
+    void persistCurrentChainId(client, undefined);
+  }
+}
+
+export async function purgeOrphanedSessions(
+  client: SignClientInstance
+): Promise<void> {
+  const pairingTopics = new Set(
+    client.pairing.getAll().map((pairing) => pairing.topic)
+  );
+
+  for (const session of [...client.session.getAll()]) {
+    const pairingOrphaned =
+      !!session.pairingTopic && !pairingTopics.has(session.pairingTopic);
+    const sessionMissing = !hasActiveSession(client, session.topic);
+
+    if (pairingOrphaned || sessionMissing) {
+      await removeSessionRecord(client, session);
+    }
+  }
+}
+
+/**
+ * Drops pairings that no session is using.
+ *
+ * The inverse of {@link purgeOrphanedSessions}, and the only thing that collects
+ * them: a cancelled connect leaves behind the pairing `client.connect()` minted,
+ * and `cleanupPendingPairings` only unsubscribes pairings - it never deletes the
+ * record. Without this they accumulate in `client.pairing` and in storage for the
+ * lifetime of the origin.
+ *
+ * Only safe to call while no connect is in flight (the adapter's `#sessionQueue`
+ * guarantees that): a pairing awaiting its first approval has no session yet, so
+ * dropping it would kill that handshake.
+ */
+export async function purgeOrphanedPairings(
+  client: SignClientInstance
+): Promise<void> {
+  const usedPairingTopics = new Set(
+    client.session
+      .getAll()
+      .map((session) => session.pairingTopic)
+      .filter((topic): topic is string => !!topic)
+  );
+
+  for (const pairing of [...client.pairing.getAll()]) {
+    if (usedPairingTopics.has(pairing.topic)) {
+      continue;
+    }
+
+    try {
+      await client.disconnect({
+        topic: pairing.topic,
+        reason: getSdkError('USER_DISCONNECTED'),
+      });
+    } catch (error) {
+      debug(error instanceof Error ? error : new Error(String(error)));
+      await expireWalletConnectTopic(client, pairing.topic);
+    }
+  }
+}
+
+export async function cleanupStaleSessionsForNamespace(
+  client: UniversalProvider['client'],
+  namespace: WalletConnectNamespace
+): Promise<void> {
+  for (const existing of client.session.getAll()) {
+    if (getSessionNamespace(existing) !== namespace) {
+      continue;
+    }
+
+    const btc = existing.namespaces[NAMESPACES.BITCOIN];
+    if (
+      btc &&
+      (btc.chains?.length ?? 0) > 0 &&
+      (btc.accounts?.length ?? 0) === 0
+    ) {
+      await removeSessionRecord(client, existing);
+    }
+  }
+}

package/src/signer.ts

@@ -1,35 +1,27 @@
-import type { WCInstance } from './types.js';
 import type { SignerFactory } from 'rango-types';
 
 import { dynamicImportWithRefinedError } from '@rango-dev/wallets-shared';
 import { DefaultSignerFactory, TransactionType as TxType } from 'rango-types';
 
-export default async function getSigners(
-  instance: WCInstance
-): Promise<SignerFactory> {
-  if (!instance.session) {
-    throw new Error('Session is required for wallet connect signers.');
+import { getAdapter } from './adapter/registry.js';
+
+export default async function getSigners(): Promise<SignerFactory> {
+  const adapter = getAdapter();
+  if (!adapter) {
+    throw new Error('WalletConnect provider has not been initialized.');
   }
 
+  const client = await adapter.getClient();
+
   const signers = new DefaultSignerFactory();
   const EVMSigner = (
     await dynamicImportWithRefinedError(
       async () => await import('./signers/evm.js')
     )
   ).default;
-  const SOLANASigner = (
-    await dynamicImportWithRefinedError(
-      async () => await import('./signers/solana.js')
-    )
-  ).default;
-
   signers.registerSigner(
     TxType.EVM,
-    new EVMSigner(instance.client, instance.session)
-  );
-  signers.registerSigner(
-    TxType.SOLANA,
-    new SOLANASigner(instance.client, instance.session)
+    new EVMSigner(client, () => adapter.getSession('evm'))
   );
 
   return signers;

package/src/signers/evm.ts

@@ -1,16 +1,17 @@
-import type { SignClient } from '@walletconnect/sign-client/dist/types/client';
-import type { SessionTypes } from '@walletconnect/types';
+import type { ISignClient, SessionTypes } from '@walletconnect/types';
 import type { EvmTransaction } from 'rango-types/mainApi';
 
 import { cleanEvmError, toHexQuantity } from '@rango-dev/signer-evm';
-import * as encoding from '@walletconnect/encoding';
 import { AccountId, ChainId } from 'caip';
 import { type GenericSigner } from 'rango-types';
 
-import { EthereumRPCMethods, NAMESPACES } from '../constants.js';
+import { utf8ToHex } from '../utils.js';
+import { EthereumRPCMethods, NAMESPACES } from '../wcConstants.js';
 
 const NAMESPACE_NAME = NAMESPACES.ETHEREUM;
 
+type SessionGetter = () => SessionTypes.Struct | null;
+
 type WalletConnectEvmTx = {
   from?: string;
   to?: string;
@@ -24,12 +25,20 @@ type WalletConnectEvmTx = {
 };
 
 class EVMSigner implements GenericSigner<EvmTransaction> {
-  private client: SignClient;
-  private session: SessionTypes.Struct;
+  private client: ISignClient;
+  private getSession: SessionGetter;
 
-  constructor(client: SignClient, session: SessionTypes.Struct) {
+  constructor(client: ISignClient, getSession: SessionGetter) {
     this.client = client;
-    this.session = session;
+    this.getSession = getSession;
+  }
+
+  private get session(): SessionTypes.Struct {
+    const session = this.getSession();
+    if (!session) {
+      throw new Error('EVM WalletConnect session is not available.');
+    }
+    return session;
   }
 
   /**
@@ -89,7 +98,7 @@ class EVMSigner implements GenericSigner<EvmTransaction> {
       namespace: NAMESPACE_NAME,
       reference: requestedFor.chainId,
     });
-    const hexMsg = encoding.utf8ToHex(msg, true);
+    const hexMsg = utf8ToHex(msg, true);
 
     const params = [hexMsg, address];
 
@@ -141,6 +150,7 @@ class EVMSigner implements GenericSigner<EvmTransaction> {
           `Received an invalid hash on signing the transaction. (hash=${hash})`
         );
       }
+
       return {
         hash,
       };
@@ -165,7 +175,6 @@ class EVMSigner implements GenericSigner<EvmTransaction> {
     const { address, chainId } = requestedFor;
 
     if (!chainId) {
-      console.log('isNetworkAndAccountExistInSession', requestedFor);
       throw new Error(
         'You need to set your chain for signing message/transaction.'
       );
@@ -191,13 +200,6 @@ class EVMSigner implements GenericSigner<EvmTransaction> {
     );
 
     if (!addresses || !addresses.includes(caipAddress.toString())) {
-      console.warn(
-        'Available adresses and requested address:',
-        addresses,
-        caipAddress.toString(),
-        chainId,
-        address
-      );
       throw new Error(
         `Your requested address doesn't exist on your wallect connect session. Please reconnect your wallet.`
       );

package/src/types.ts

@@ -1,26 +1,45 @@
-import type { SignClient } from '@walletconnect/sign-client/dist/types/client';
-import type { ProposalTypes, SessionTypes } from '@walletconnect/types';
+import type { ProposalTypes } from '@walletconnect/types';
+import type { ChainIdParams } from 'caip';
 import type { BlockchainMeta } from 'rango-types';
 
-export interface Environments extends Record<string, string | undefined> {
+import { SignClient } from '@walletconnect/sign-client';
+
+export { SignClient };
+
+export type SignClientInstance = InstanceType<typeof SignClient>;
+
+export interface Environments {
   WC_PROJECT_ID: string;
   // This is useful for directly opening a listed WC wallet. you will need to pass a url.
   DISABLE_MODAL_AND_OPEN_LINK?: string;
+  meta?: BlockchainMeta[];
+  themeMode?: 'light' | 'dark';
+  modalZIndex?: number;
 }
-export interface WCInstance {
-  client: SignClient;
-  session: SessionTypes.Struct | null;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  request: (params: any) => Promise<string>;
-}
+
+export type WalletConnectNamespace = 'evm' | 'utxo';
 
 export interface CreateSessionParams {
-  requiredNamespaces: ProposalTypes.RequiredNamespaces;
-  optionalNamespaces?: ProposalTypes.OptionalNamespaces;
+  /**
+   * The whole proposal goes here - sign-client folds `requiredNamespaces` into
+   * this and clears it, so proposing anything as required is deprecated.
+   */
+  optionalNamespaces: ProposalTypes.OptionalNamespaces;
   pairingTopic?: string;
 }
 
 export interface ConnectParams {
-  meta: BlockchainMeta[];
+  /**
+   * Chains to propose, as CAIP-2 ids. Callers convert rango `BlockchainMeta`
+   * at the boundary (see `evmMetaToCaipChainIds`) so the connect path stays
+   * decoupled from rango-types' chain shape.
+   */
+  chains: ChainIdParams[];
   envs: Environments;
+  namespace: WalletConnectNamespace;
+  /**
+   * Decimal EVM chain reference (e.g. `"137"`).
+   * When set, it is the only EVM chain proposed during session creation.
+   */
+  chainReference?: string;
 }

package/src/utils.ts

@@ -0,0 +1,68 @@
+import type { Chain } from '@hub3js/evm';
+import type { ChainIdParams } from 'caip';
+import type { BlockchainMeta } from 'rango-types';
+
+import { isEvmBlockchain } from 'rango-types';
+
+import { NAMESPACES } from './wcConstants.js';
+
+const HEX_RADIX = 16;
+
+export function utf8ToHex(value: string, prefixed = false): string {
+  const hex = Array.from(new TextEncoder().encode(value))
+    .map((byte) => byte.toString(HEX_RADIX).padStart(2, '0'))
+    .join('');
+
+  return prefixed ? `0x${hex}` : hex;
+}
+
+/** Normalizes hub chain input (hex, decimal, or AddEthereumChainParameter) to a decimal reference. */
+export function parseChainReference(
+  chain?: string | Chain
+): string | undefined {
+  if (!chain) {
+    return undefined;
+  }
+
+  if (typeof chain === 'string') {
+    return chain.startsWith('0x')
+      ? String(parseInt(chain))
+      : String(parseInt(chain, 10) || chain);
+  }
+
+  return String(parseInt(chain.chainId));
+}
+
+/** Maps a chain reference to a Rango network name using blockchain meta. */
+export function resolveNetworkName(
+  chain: string | Chain | null | undefined,
+  meta: BlockchainMeta[]
+): string | undefined {
+  const reference = parseChainReference(chain ?? undefined);
+  if (!reference) {
+    return undefined;
+  }
+
+  return meta.find(
+    (blockchain) =>
+      isEvmBlockchain(blockchain) &&
+      String(parseInt(blockchain.chainId)) === reference
+  )?.name;
+}
+
+/** Converts a decimal EVM chain reference to the `0x`-prefixed hex expected by hub EVM actions. */
+export function chainReferenceToHex(reference: string): `0x${string}` {
+  return `0x${parseInt(reference).toString(HEX_RADIX)}`;
+}
+
+/**
+ * Converts rango EVM blockchain meta to CAIP-2 chain ids - the only chain data the
+ * connect/proposal path needs. This is the single boundary where rango-types' chain
+ * shape is translated; everything downstream uses caip's ChainIdParams.
+ */
+export function evmMetaToCaipChainIds(meta: BlockchainMeta[]): ChainIdParams[] {
+  return meta.filter(isEvmBlockchain).map((blockchain) => ({
+    namespace: NAMESPACES.ETHEREUM,
+    reference: String(parseInt(blockchain.chainId)),
+  }));
+}

package/src/wcConstants.ts

@@ -0,0 +1,94 @@
+/**
+ * WalletConnect protocol constants shared across the hub path (session/,
+ * adapter/, signers/, namespaces/). Kept separate from `constants.ts` (which
+ * holds the hub provider identity/metadata) so this module stays a dependency
+ * leaf and importing it never pulls in the signer/provider graph (the
+ * `WalletConnectNamespace` import below is type-only, so it is erased at runtime).
+ */
+import type { WalletConnectNamespace } from './types.js';
+
+export const PING_TIMEOUT = 10_000;
+
+export enum NAMESPACES {
+  ETHEREUM = 'eip155',
+  BITCOIN = 'bip122',
+  POLKADOT = 'polkadot',
+  CARDANO = 'cip34',
+  ERLOND = 'elrond',
+  MULTIVERSX = 'multiversx',
+}
+
+/**
+ * Single source of truth for the namespace-alias -> CAIP-2 prefix relationship
+ * (`evm -> eip155`, `utxo -> bip122`). `proposals` and `lookup` read from this
+ * instead of re-encoding it. `Record<WalletConnectNamespace, …>` makes a new
+ * alias a compile error until it's mapped.
+ */
+export const WC_NAMESPACE_TO_CAIP: Record<WalletConnectNamespace, string> = {
+  evm: NAMESPACES.ETHEREUM,
+  utxo: NAMESPACES.BITCOIN,
+};
+
+export const CHAIN_ID_STORAGE = 'wc@2:client//namespaces';
+
+// Refrence: https://docs.walletconnect.com/2.0/advanced/rpc-reference/ethereum-rpc
+export enum EthereumRPCMethods {
+  PERSONAL_SIGN = 'personal_sign',
+  SIGN = 'eth_sign',
+  SIGN_TYPED_DATA = 'eth_signTypedData',
+  SIGN_TRANSACTION = 'eth_signTransaction',
+  SEND_TRANSACTION = 'eth_sendTransaction',
+  SEND_RAW_TRANSACTION = 'eth_sendRawTransaction',
+  SWITCH_CHAIN = 'wallet_switchEthereumChain',
+  ADD_CHAIN = 'wallet_addEthereumChain',
+  GET_CHAIN = 'eth_chainId',
+}
+
+export enum EthereumEvents {
+  CHAIN_CHANGED = 'chainChanged',
+  ACCOUNTS_CHANGED = 'accountsChanged',
+}
+
+export const DEFAULT_ETHEREUM_EVENTS: EthereumEvents[] = [
+  EthereumEvents.CHAIN_CHANGED,
+  EthereumEvents.ACCOUNTS_CHANGED,
+];
+
+export const DEFAULT_ETHEREUM_METHODS = [
+  EthereumRPCMethods.PERSONAL_SIGN,
+  EthereumRPCMethods.SEND_TRANSACTION,
+  EthereumRPCMethods.SIGN_TRANSACTION,
+  EthereumRPCMethods.SWITCH_CHAIN,
+  EthereumRPCMethods.ADD_CHAIN,
+  EthereumRPCMethods.GET_CHAIN,
+];
+
+// Reference: https://docs.reown.com/advanced/multichain/rpc-reference/bitcoin-rpc
+export enum BitcoinRPCMethods {
+  SIGN_PSBT = 'signPsbt',
+  GET_ACCOUNT_ADDRESSES = 'getAccountAddresses',
+  SIGN_MESSAGE = 'signMessage',
+  SEND_TRANSFER = 'sendTransfer',
+}
+
+export enum BitcoinEvents {
+  ADDRESSES_CHANGED = 'bip122_addressesChanged',
+}
+
+export const DEFAULT_BITCOIN_EVENTS: BitcoinEvents[] = [
+  BitcoinEvents.ADDRESSES_CHANGED,
+];
+
+export const DEFAULT_BITCOIN_METHODS = [
+  BitcoinRPCMethods.SIGN_PSBT,
+  BitcoinRPCMethods.GET_ACCOUNT_ADDRESSES,
+];
+
+export const DEFAULT_APP_METADATA = {
+  name: 'Rango Exchange',
+  description: 'The Ultimate Cross-Chain Solution',
+  url: 'https://app.rango.exchange/',
+  icons: ['https://app.rango.exchange/logo-rounded.png'],
+};
+
+export const RELAY_URL = 'wss://relay.walletconnect.com';

package/dist/chunk-6V3WUFOU.js

@@ -1,2 +0,0 @@
-import{Networks as n}from"@rango-dev/wallets-shared";var T=n.ETHEREUM,A=1e4;var e="wc@2:client//namespaces";var t=["chainChanged","accountsChanged"],N=["personal_sign","eth_sendTransaction","eth_signTransaction","wallet_switchEthereumChain","wallet_addEthereumChain","eth_chainId"];var a="4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ",o={name:"Rango Exchange",description:"The Ultimate Cross-Chain Solution",url:"https://app.rango.exchange/",icons:["https://app.rango.exchange/logo-rounded.png"]},s="wss://relay.walletconnect.com";export{T as a,A as b,e as c,t as d,N as e,a as f,o as g,s as h};
-//# sourceMappingURL=chunk-6V3WUFOU.js.map

package/dist/chunk-6V3WUFOU.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/constants.ts"],
-  "sourcesContent": ["import { Networks } from '@rango-dev/wallets-shared';\n\nexport const DEFAULT_NETWORK = Networks.ETHEREUM;\nexport const PING_TIMEOUT = 10_000;\n\nexport enum NAMESPACES {\n  ETHEREUM = 'eip155',\n  SOLANA = 'solana',\n  POLKADOT = 'polkadot',\n  CARDANO = 'cip34',\n  ERLOND = 'elrond',\n  MULTIVERSX = 'multiversx',\n}\n\nexport const CHAIN_ID_STORAGE = 'wc@2:client//namespaces';\n\n// Refrence: https://docs.walletconnect.com/2.0/advanced/rpc-reference/solana-rpc\nexport enum SolanaRPCMethods {\n  GET_ACCOUNTS = 'solana_getAccounts',\n  REQUEST_ACCOUNTS = 'solana_requestAccounts',\n  SIGN_TRANSACTION = 'solana_signTransaction',\n  SIGN_MESSAGE = 'solana_signMessage',\n}\n\n// Refrence: https://docs.walletconnect.com/2.0/advanced/rpc-reference/ethereum-rpc\nexport enum EthereumRPCMethods {\n  PERSONAL_SIGN = 'personal_sign',\n  SIGN = 'eth_sign',\n  SIGN_TYPED_DATA = 'eth_signTypedData',\n  SIGN_TRANSACTION = 'eth_signTransaction',\n  SEND_TRANSACTION = 'eth_sendTransaction',\n  SEND_RAW_TRANSACTION = 'eth_sendRawTransaction',\n  SWITCH_CHAIN = 'wallet_switchEthereumChain',\n  ADD_CHAIN = 'wallet_addEthereumChain',\n  GET_CHAIN = 'eth_chainId',\n}\n\nexport enum StarknetRPCMethods {\n  REQUEST_ADD_INVOKE_TRANSACTION = 'starknet_requestAddInvokeTransaction',\n  SIGN_TYPED_DATA = 'starknet_signTypedData',\n}\n\nexport enum EthereumEvents {\n  CHAIN_CHANGED = 'chainChanged',\n  ACCOUNTS_CHANGED = 'accountsChanged',\n}\n\nexport const DEFAULT_ETHEREUM_EVENTS: EthereumEvents[] = [\n  EthereumEvents.CHAIN_CHANGED,\n  EthereumEvents.ACCOUNTS_CHANGED,\n];\n\nexport const DEFAULT_ETHEREUM_METHODS = [\n  EthereumRPCMethods.PERSONAL_SIGN,\n  EthereumRPCMethods.SEND_TRANSACTION,\n  EthereumRPCMethods.SIGN_TRANSACTION,\n  EthereumRPCMethods.SWITCH_CHAIN,\n  EthereumRPCMethods.ADD_CHAIN,\n  EthereumRPCMethods.GET_CHAIN,\n];\n\nexport const DEFAULT_SOLANA_METHODS = [\n  SolanaRPCMethods.SIGN_TRANSACTION,\n  SolanaRPCMethods.SIGN_MESSAGE,\n];\n\n// refrence: https://github.com/ChainAgnostic/namespaces/blob/main/solana/caip2.md\nexport const DEFAULT_SOLANA_CHAIN_ID = '4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ';\n\nexport const DEFAULT_APP_METADATA = {\n  name: 'Rango Exchange',\n  description: 'The Ultimate Cross-Chain Solution',\n  url: 'https://app.rango.exchange/',\n  icons: ['https://app.rango.exchange/logo-rounded.png'],\n};\n\nexport const RELAY_URL = 'wss://relay.walletconnect.com';\n"],
-  "mappings": "AAAA,OAAS,YAAAA,MAAgB,4BAElB,IAAMC,EAAkBD,EAAS,SAC3BE,EAAe,IAWrB,IAAMC,EAAmB,0BAiCzB,IAAMC,EAA4C,CACvD,eACA,iBACF,EAEaC,EAA2B,CACtC,gBACA,sBACA,sBACA,6BACA,0BACA,aACF,EAQO,IAAMC,EAA0B,mCAE1BC,EAAuB,CAClC,KAAM,iBACN,YAAa,oCACb,IAAK,8BACL,MAAO,CAAC,6CAA6C,CACvD,EAEaC,EAAY",
-  "names": ["Networks", "DEFAULT_NETWORK", "PING_TIMEOUT", "CHAIN_ID_STORAGE", "DEFAULT_ETHEREUM_EVENTS", "DEFAULT_ETHEREUM_METHODS", "DEFAULT_SOLANA_CHAIN_ID", "DEFAULT_APP_METADATA", "RELAY_URL"]
-}