@swapkit/wallets 4.8.0 → 4.8.1

package/src/walletconnect/evmSigner.ts

@@ -0,0 +1,116 @@
+import { type EVMChain, SwapKitError, WalletOption } from "@swapkit/helpers";
+import type {
+  JsonRpcProvider,
+  Provider,
+  TransactionRequest,
+  TransactionResponse,
+  TypedDataDomain,
+  TypedDataField,
+} from "ethers";
+import { AbstractSigner } from "ethers";
+
+import { DEFAULT_EIP155_METHODS } from "./constants";
+import { chainToChainId, getAddressByChain } from "./helpers";
+import type { Walletconnect } from "./index";
+
+interface WalletconnectEVMSignerParams {
+  chain: EVMChain;
+  walletconnect: Walletconnect;
+  provider: Provider | JsonRpcProvider;
+}
+
+class WalletconnectSigner extends AbstractSigner {
+  address: string;
+
+  private chain: EVMChain;
+  private walletconnect: Walletconnect;
+  readonly provider: Provider | JsonRpcProvider;
+
+  constructor({ chain, provider, walletconnect }: WalletconnectEVMSignerParams) {
+    super(provider);
+    this.chain = chain;
+    this.walletconnect = walletconnect;
+    this.provider = provider;
+    this.address = "";
+  }
+
+  // biome-ignore lint/suspicious/useAwait: fulfil implementation type
+  getAddress = async () => {
+    if (!this.walletconnect) {
+      throw new SwapKitError("wallet_walletconnect_connection_not_established");
+    }
+    if (!this.address) {
+      this.address = getAddressByChain(this.chain, this.walletconnect.accounts || []);
+    }
+
+    return this.address;
+  };
+
+  signMessage = async (message: string) => {
+    // this is probably broken
+    const txHash = (await this.walletconnect?.client.request({
+      chainId: chainToChainId(this.chain),
+      request: { method: DEFAULT_EIP155_METHODS.ETH_SIGN, params: [message] },
+      topic: this.walletconnect.session.topic || "",
+    })) as string;
+
+    return txHash.startsWith("0x") ? txHash : `0x${txHash}`;
+  };
+
+  signTransaction = () => {
+    throw new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signTransaction" });
+
+    // const baseTx = {
+    //   from,
+    //   to,
+    //   value: BigNumber.from(value || 0).toHexString(),
+    //   data,
+    // };
+
+    // const txHash = (await this.walletconnect?.client.request({
+    //   chainId: chainToChainId(this.chain),
+    //   topic: this.walletconnect.session.topic,
+    //   request: {
+    //     method: DEFAULT_EIP155_METHODS.ETH_SIGN_TRANSACTION,
+    //     params: [baseTx],
+    //   },
+    // })) as string;
+
+    // return txHash.startsWith('0x') ? txHash : `0x${txHash}`;
+  };
+
+  signTypedData = (
+    _domain: TypedDataDomain,
+    _types: Record<string, TypedDataField[]>,
+    _value: Record<string, unknown>,
+    _explicitPrimaryType?: string,
+  ) => {
+    throw new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signTransaction" });
+  };
+
+  sendTransaction = async ({ from, to, value, data }: TransactionRequest) => {
+    const { toHexString } = await import("@swapkit/toolboxes/evm");
+
+    const baseTx = { data, from, to, value: toHexString(BigInt(value || 0)) };
+    const response = await this.walletconnect?.client.request({
+      chainId: chainToChainId(this.chain),
+      request: { method: DEFAULT_EIP155_METHODS.ETH_SEND_TRANSACTION, params: [baseTx] },
+      topic: this.walletconnect.session.topic,
+    });
+
+    return response as TransactionResponse;
+  };
+
+  connect = (provider: Provider | null) => {
+    if (!provider) {
+      throw new SwapKitError({
+        errorKey: "wallet_provider_not_found",
+        info: { chain: this.chain, wallet: WalletOption.WALLETCONNECT },
+      });
+    }
+
+    return new WalletconnectSigner({ chain: this.chain, provider, walletconnect: this.walletconnect });
+  };
+}
+export const getEVMSigner = async ({ chain, walletconnect, provider }: WalletconnectEVMSignerParams) =>
+  new WalletconnectSigner({ chain, provider, walletconnect });

package/src/walletconnect/helpers.ts

@@ -0,0 +1,76 @@
+import { Chain, type CosmosChain, type EVMChain, SKConfig } from "@swapkit/helpers";
+
+import {
+  ARBITRUM_ONE_MAINNET_ID,
+  AURORA_MAINNET_ID,
+  AVALANCHE_MAINNET_ID,
+  BASE_MAINNET_ID,
+  BERACHAIN_MAINNET_ID,
+  BSC_MAINNET_ID,
+  COSMOS_HUB_MAINNET_ID,
+  ETHEREUM_MAINNET_ID,
+  KUJIRA_MAINNET_ID,
+  MAYACHAIN_MAINNET_ID,
+  MONAD_MAINNET_ID,
+  NEAR_MAINNET_ID,
+  NEAR_TESTNET_ID,
+  OPTIMISM_MAINNET_ID,
+  POLYGON_MAINNET_ID,
+  THORCHAIN_MAINNET_ID,
+  TRON_MAINNET_ID,
+  XLAYER_MAINNET_ID,
+} from "./constants";
+
+export const getAddressByChain = (
+  chain: EVMChain | Exclude<CosmosChain, typeof Chain.Noble> | typeof Chain.Near | typeof Chain.Tron,
+  accounts: string[],
+) => {
+  const account = accounts.find((account) => account.startsWith(chainToChainId(chain))) || "";
+  const address = account?.split(":")?.[2];
+
+  return address || "";
+};
+
+export const chainToChainId = (chain: Chain) => {
+  switch (chain) {
+    case Chain.Avalanche:
+      return AVALANCHE_MAINNET_ID;
+    case Chain.Aurora:
+      return AURORA_MAINNET_ID;
+    case Chain.Base:
+      return BASE_MAINNET_ID;
+    case Chain.BinanceSmartChain:
+      return BSC_MAINNET_ID;
+    case Chain.Berachain:
+      return BERACHAIN_MAINNET_ID;
+    case Chain.Monad:
+      return MONAD_MAINNET_ID;
+    case Chain.Ethereum:
+      return ETHEREUM_MAINNET_ID;
+    case Chain.THORChain:
+      return THORCHAIN_MAINNET_ID;
+    case Chain.Arbitrum:
+      return ARBITRUM_ONE_MAINNET_ID;
+    case Chain.Optimism:
+      return OPTIMISM_MAINNET_ID;
+    case Chain.Polygon:
+      return POLYGON_MAINNET_ID;
+    case Chain.Maya:
+      return MAYACHAIN_MAINNET_ID;
+    case Chain.Cosmos:
+      return COSMOS_HUB_MAINNET_ID;
+    case Chain.Kujira:
+      return KUJIRA_MAINNET_ID;
+    case Chain.Near: {
+      // Use testnet if stagenet is enabled
+      const { isStagenet } = SKConfig.get("envs");
+      return isStagenet ? NEAR_TESTNET_ID : NEAR_MAINNET_ID;
+    }
+    case Chain.Tron:
+      return TRON_MAINNET_ID;
+    case Chain.XLayer:
+      return XLAYER_MAINNET_ID;
+    default:
+      return "";
+  }
+};

package/src/walletconnect/index.ts

@@ -0,0 +1,409 @@
+import type { StdSignDoc } from "@cosmjs/amino";
+import type { Transaction } from "@near-js/transactions";
+import {
+  Chain,
+  filterSupportedChains,
+  type GenericTransferParams,
+  getRPCUrl,
+  SKConfig,
+  SwapKitError,
+  WalletOption,
+} from "@swapkit/helpers";
+import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
+import type { NearSigner } from "@swapkit/toolboxes/near";
+import type { TronSignedTransaction, TronSigner, TronTransaction } from "@swapkit/toolboxes/tron";
+import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
+import type { WalletConnectModal } from "@walletconnect/modal";
+import type { SignClient } from "@walletconnect/sign-client";
+import type { SessionTypes, SignClientTypes } from "@walletconnect/types";
+import {
+  DEFAULT_APP_METADATA,
+  DEFAULT_COSMOS_METHODS,
+  DEFAULT_LOGGER,
+  DEFAULT_RELAY_URL,
+  THORCHAIN_MAINNET_ID,
+} from "./constants";
+import { getEVMSigner } from "./evmSigner";
+import { chainToChainId, getAddressByChain } from "./helpers";
+import { getRequiredNamespaces } from "./namespaces";
+
+export * from "./constants";
+export * from "./types";
+
+export const walletconnectWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectWalletconnect(chains: Chain[], walletconnectOptions?: SignClientTypes.Options) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+      const { walletConnectProjectId } = SKConfig.get("apiKeys");
+
+      if (!walletConnectProjectId) {
+        throw new SwapKitError("wallet_walletconnect_project_id_not_specified");
+      }
+
+      const walletconnect = await getWalletconnect(filteredChains, walletConnectProjectId, walletconnectOptions);
+
+      if (!walletconnect) {
+        throw new SwapKitError("wallet_walletconnect_connection_not_established");
+      }
+
+      const { accounts } = walletconnect;
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const address = getAddressByChain(chain, accounts || []);
+          const toolbox = await getToolbox({ address, chain, walletconnect });
+
+          addChain({
+            ...toolbox,
+            address,
+            chain,
+            disconnect: walletconnect.disconnect,
+            walletType: WalletOption.WALLETCONNECT,
+          });
+        }),
+      );
+
+      return true;
+    },
+  directSigningSupport: {
+    [Chain.Arbitrum]: true,
+    [Chain.Aurora]: true,
+    [Chain.Avalanche]: true,
+    [Chain.Base]: true,
+    [Chain.Berachain]: true,
+    [Chain.BinanceSmartChain]: true,
+    [Chain.Ethereum]: true,
+    [Chain.Monad]: true,
+    [Chain.Optimism]: true,
+    [Chain.Polygon]: true,
+    [Chain.XLayer]: true,
+    // Cosmos/Kujira/Maya/THORChain: cosmos toolbox built without signer; Tron/Near: signer wired but pending hardening (V3 plan PRs)
+  },
+  name: "connectWalletconnect",
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Aurora,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.Berachain,
+    Chain.BinanceSmartChain,
+    Chain.Cosmos,
+    Chain.Ethereum,
+    Chain.Kujira,
+    Chain.Maya,
+    Chain.Monad,
+    Chain.Near,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.THORChain,
+    Chain.Tron,
+    Chain.XLayer,
+  ],
+  walletType: WalletOption.WALLETCONNECT,
+});
+
+export const WC_SUPPORTED_CHAINS = getWalletSupportedChains(walletconnectWallet);
+export type Walletconnect = Awaited<ReturnType<typeof getWalletconnect>>;
+
+async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
+  chain,
+  walletconnect,
+  address,
+}: {
+  walletconnect: Walletconnect;
+  chain: T;
+  address: string;
+}) {
+  const session = walletconnect?.session;
+  if (!session) {
+    throw new SwapKitError("wallet_walletconnect_connection_not_established");
+  }
+
+  switch (chain) {
+    case Chain.Arbitrum:
+    case Chain.Aurora:
+    case Chain.Avalanche:
+    case Chain.Base:
+    case Chain.Berachain:
+    case Chain.BinanceSmartChain:
+    case Chain.Ethereum:
+    case Chain.Monad:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.XLayer: {
+      const { getProvider, getEvmToolboxAsync } = await import("@swapkit/toolboxes/evm");
+
+      const provider = await getProvider(chain);
+      const signer = await getEVMSigner({ chain, provider, walletconnect });
+      const toolbox = await getEvmToolboxAsync(chain, { provider, signer });
+
+      return toolbox;
+    }
+
+    case Chain.THORChain: {
+      const { SignMode } = await import("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
+      const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx.js");
+
+      const importedSigning = await import("@cosmjs/proto-signing");
+      const encodePubkey = importedSigning.encodePubkey ?? importedSigning.default?.encodePubkey;
+      const makeAuthInfoBytes = importedSigning.makeAuthInfoBytes ?? importedSigning.default?.makeAuthInfoBytes;
+      const importedAmino = await import("@cosmjs/amino");
+      const makeSignDoc = importedAmino.makeSignDoc ?? importedSigning.default?.makeSignDoc;
+
+      const {
+        getCosmosToolbox,
+        buildAminoMsg,
+        buildEncodedTxBody,
+        createStargateClient,
+        fromBase64,
+        getDefaultChainFee,
+        parseAminoMessageForDirectSigning,
+      } = await import("@swapkit/toolboxes/cosmos");
+      const toolbox = await getCosmosToolbox(chain);
+
+      const fee = getDefaultChainFee(chain);
+
+      const signRequest = (signDoc: StdSignDoc) =>
+        walletconnect?.client.request({
+          chainId: THORCHAIN_MAINNET_ID,
+          request: { method: DEFAULT_COSMOS_METHODS.COSMOS_SIGN_AMINO, params: { signDoc, signerAddress: address } },
+          topic: session.topic,
+        });
+
+      async function thorchainTransfer({ assetValue, memo, ...rest }: GenericTransferParams | ThorchainDepositParams) {
+        const account = await toolbox.getAccount(address);
+        if (!account) {
+          throw new SwapKitError({ errorKey: "wallet_missing_params", info: { account } });
+        }
+
+        if (!account.pubkey) {
+          throw new SwapKitError({ errorKey: "wallet_missing_params", info: { account, pubkey: account?.pubkey } });
+        }
+
+        const { accountNumber, sequence = 0 } = account;
+
+        const msgs = [buildAminoMsg({ ...rest, assetValue, memo, sender: address })];
+
+        const signDoc = makeSignDoc(
+          msgs,
+          fee,
+          assetValue.chainId,
+          memo,
+          accountNumber?.toString(),
+          sequence?.toString() || "0",
+        );
+
+        const signature: any = await signRequest(signDoc);
+
+        const bodyBytes = await buildEncodedTxBody({
+          chain: Chain.THORChain,
+          memo: memo || "",
+          msgs: msgs.map(parseAminoMessageForDirectSigning),
+        });
+        const pubkey = encodePubkey(account.pubkey);
+        const authInfoBytes = makeAuthInfoBytes(
+          [{ pubkey, sequence }],
+          fee.amount,
+          Number.parseInt(fee.gas, 10),
+          undefined,
+          undefined,
+          SignMode.SIGN_MODE_LEGACY_AMINO_JSON,
+        );
+
+        const txRaw = TxRaw.fromPartial({
+          authInfoBytes,
+          bodyBytes,
+          signatures: [
+            fromBase64(typeof signature.signature === "string" ? signature.signature : signature.signature.signature),
+          ],
+        });
+        const txBytes = TxRaw.encode(txRaw).finish();
+
+        const rpcUrl = await getRPCUrl(Chain.THORChain);
+        const broadcaster = await createStargateClient(rpcUrl);
+        const result = await broadcaster.broadcastTx(txBytes);
+        return result.transactionHash;
+      }
+
+      return {
+        ...toolbox,
+        deposit: (params: ThorchainDepositParams) => thorchainTransfer(params),
+        transfer: (params: GenericTransferParams) => thorchainTransfer(params),
+      };
+    }
+
+    case Chain.Near: {
+      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
+      const { DEFAULT_NEAR_METHODS } = await import("./constants");
+
+      // Create a NEAR signer that uses WalletConnect
+      const signer = {
+        getAddress() {
+          return Promise.resolve(address);
+        },
+        getPublicKey() {
+          // WalletConnect NEAR doesn't expose public key directly
+          return Promise.reject(
+            new SwapKitError("wallet_walletconnect_method_not_supported", { method: "getPublicKey" }),
+          );
+        },
+
+        signDelegateAction(_delegateAction: any) {
+          return Promise.reject(
+            new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signDelegateAction" }),
+          );
+        },
+
+        signNep413Message(
+          _message: string,
+          _accountId: string,
+          _recipient: string,
+          _nonce: Uint8Array,
+          _callbackUrl?: string,
+        ) {
+          // WalletConnect NEAR spec doesn't include NEP-413 message signing
+          return Promise.reject(
+            new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signNep413Message" }),
+          );
+        },
+
+        async signTransaction(transaction: Transaction) {
+          if (!walletconnect) {
+            throw new SwapKitError("wallet_walletconnect_connection_not_established");
+          }
+          // WalletConnect signs and sends in one operation
+          const result = await walletconnect.client.request({
+            chainId: chainToChainId(Chain.Near),
+            request: { method: DEFAULT_NEAR_METHODS.NEAR_SIGN_AND_SEND_TRANSACTION, params: { transaction } },
+            topic: session.topic,
+          });
+          // Return dummy hash and result
+          return [new Uint8Array(32), result];
+        },
+      } as NearSigner;
+
+      const toolbox = getNearToolbox({ signer });
+      return toolbox;
+    }
+
+    case Chain.Tron: {
+      const { getTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const { DEFAULT_TRON_METHODS } = await import("./constants");
+
+      // Create a Tron signer that uses WalletConnect
+      const signer: TronSigner = {
+        getAddress() {
+          return Promise.resolve(address);
+        },
+
+        async signTransaction(transaction: TronTransaction) {
+          if (!walletconnect) {
+            throw new SwapKitError("wallet_walletconnect_connection_not_established");
+          }
+
+          const signedTx = await walletconnect.client.request({
+            chainId: chainToChainId(Chain.Tron),
+            request: { method: DEFAULT_TRON_METHODS.TRON_SIGN_TRANSACTION, params: { transaction } },
+            topic: session.topic,
+          });
+
+          return signedTx as TronSignedTransaction;
+        },
+      };
+
+      const toolbox = getTronToolbox({ signer });
+
+      return toolbox;
+    }
+
+    default:
+      throw new SwapKitError({
+        errorKey: "wallet_chain_not_supported",
+        info: { chain, wallet: WalletOption.WALLETCONNECT },
+      });
+  }
+}
+
+async function getWalletconnect(
+  chains: Chain[],
+  walletConnectProjectId: string,
+  walletconnectOptions?: SignClientTypes.Options,
+) {
+  let modal: WalletConnectModal | undefined;
+  let signer: typeof SignClient | undefined;
+  let session: SessionTypes.Struct | undefined;
+  let accounts: string[] | undefined;
+  try {
+    const requiredNamespaces = getRequiredNamespaces(chains.map(chainToChainId));
+
+    const { SignClient } = await import("@walletconnect/sign-client");
+    const { WalletConnectModal } = await import("@walletconnect/modal");
+
+    const client = await SignClient.init({
+      logger: DEFAULT_LOGGER,
+      metadata: walletconnectOptions?.metadata || DEFAULT_APP_METADATA,
+      projectId: walletConnectProjectId,
+      relayUrl: DEFAULT_RELAY_URL,
+      ...walletconnectOptions?.core,
+    });
+
+    const modal = new WalletConnectModal({
+      logger: DEFAULT_LOGGER,
+      projectId: walletConnectProjectId,
+      relayUrl: DEFAULT_RELAY_URL,
+      ...walletconnectOptions?.core,
+    });
+
+    const oldSession = (await client.session.getAll())[0];
+
+    // disconnect old Session cause we can't handle using it with current ui
+    if (oldSession) {
+      await client.disconnect({ reason: { code: 0, message: "Resetting session" }, topic: oldSession.topic });
+    }
+
+    const { uri, approval } = await client.connect({
+      // Optionally: pass a known prior pairing (e.g. from `client.core.pairing.getPairings()`) to skip the `uri` step.
+      //   pairingTopic: pairing?.topic,
+      // Provide the namespaces and chains (e.g. `eip155` for EVM-based chains) we want to use in this session.
+      requiredNamespaces,
+    });
+
+    if (uri) {
+      modal.openModal({ uri });
+      // Await session approval from the wallet.
+      session = await approval();
+      // Handle the returned session (e.g. update UI to "connected" state).
+      // Close the QRCode modal in case it was open.
+      modal.closeModal();
+
+      function extractAccountsFromSession(session: SessionTypes.Struct) {
+        const accounts: string[] = [];
+
+        for (const [_namespace, data] of Object.entries(session.namespaces)) {
+          accounts.push(...data.accounts);
+        }
+
+        return accounts;
+      }
+
+      accounts = extractAccountsFromSession(session);
+    }
+
+    const disconnect = async () => {
+      session && (await client.disconnect({ reason: { code: 0, message: "User disconnected" }, topic: session.topic }));
+    };
+
+    if (!session) {
+      throw new SwapKitError("wallet_walletconnect_connection_not_established");
+    }
+
+    return { accounts, client, disconnect, session, signer };
+  } catch {
+    // Errors are handled by returning undefined
+  } finally {
+    if (modal) {
+      modal.closeModal();
+    }
+  }
+  return undefined;
+}

package/src/walletconnect/namespaces.ts

@@ -0,0 +1,80 @@
+import { SwapKitError } from "@swapkit/helpers";
+import type { ProposalTypes } from "@walletconnect/types";
+import {
+  DEFAULT_COSMOS_METHODS,
+  DEFAULT_EIP_155_EVENTS,
+  DEFAULT_EIP155_METHODS,
+  DEFAULT_NEAR_EVENTS,
+  DEFAULT_NEAR_METHODS,
+  DEFAULT_POLKADOT_EVENTS,
+  DEFAULT_POLKADOT_METHODS,
+  DEFAULT_SOLANA_EVENTS,
+  DEFAULT_SOLANA_METHODS,
+  DEFAULT_TRON_EVENTS,
+  DEFAULT_TRON_METHODS,
+} from "./constants";
+
+export const getNamespacesFromChains = (chains: string[]) => {
+  const supportedNamespaces: string[] = [];
+  for (const chainId of chains) {
+    const [namespace] = chainId.split(":");
+    if (namespace && !supportedNamespaces.includes(namespace)) {
+      supportedNamespaces.push(namespace);
+    }
+  }
+
+  return supportedNamespaces;
+};
+
+export const getSupportedMethodsByNamespace = (namespace: string) => {
+  switch (namespace) {
+    case "eip155":
+      return Object.values(DEFAULT_EIP155_METHODS);
+    case "cosmos":
+      return Object.values(DEFAULT_COSMOS_METHODS);
+    case "solana":
+      return Object.values(DEFAULT_SOLANA_METHODS);
+    case "polkadot":
+      return Object.values(DEFAULT_POLKADOT_METHODS);
+    case "near":
+      return Object.values(DEFAULT_NEAR_METHODS);
+    case "tron":
+      return Object.values(DEFAULT_TRON_METHODS);
+    default:
+      throw new SwapKitError({ errorKey: "wallet_walletconnect_namespace_not_supported", info: { namespace } });
+  }
+};
+
+export const getSupportedEventsByNamespace = (namespace: string) => {
+  switch (namespace) {
+    case "eip155":
+      return Object.values(DEFAULT_EIP_155_EVENTS);
+    case "cosmos":
+      return [];
+    case "solana":
+      return Object.values(DEFAULT_SOLANA_EVENTS);
+    case "polkadot":
+      return Object.values(DEFAULT_POLKADOT_EVENTS);
+    case "near":
+      return Object.values(DEFAULT_NEAR_EVENTS);
+    case "tron":
+      return Object.values(DEFAULT_TRON_EVENTS);
+    default:
+      throw new SwapKitError({ errorKey: "wallet_walletconnect_namespace_not_supported", info: { namespace } });
+  }
+};
+
+export const getRequiredNamespaces = (chains: string[]): ProposalTypes.RequiredNamespaces => {
+  const selectedNamespaces = getNamespacesFromChains(chains);
+
+  return Object.fromEntries(
+    selectedNamespaces.map((namespace) => [
+      namespace,
+      {
+        chains: chains.filter((chain) => chain.startsWith(namespace)),
+        events: getSupportedEventsByNamespace(namespace) as any[],
+        methods: getSupportedMethodsByNamespace(namespace),
+      },
+    ]),
+  );
+};

package/src/walletconnect/types.ts

@@ -0,0 +1,6 @@
+export interface ClientMetadata {
+  name: string;
+  description: string;
+  url: string;
+  icons: string[];
+}