@swapkit/wallets 4.3.10 → 4.6.0

package/src/radix/index.ts

@@ -1,194 +0,0 @@
-import type {
-  FungibleResourcesCollectionItem,
-  GatewayApiClient,
-  StateEntityDetailsVaultResponseItem,
-  StateEntityFungiblesPageRequest,
-  StateEntityFungiblesPageResponse,
-} from "@radixdlt/babylon-gateway-api-sdk";
-import { AssetValue, Chain, filterSupportedChains, SKConfig, SwapKitError, WalletOption } from "@swapkit/helpers";
-import { createWallet, getWalletSupportedChains } from "@swapkit/wallet-core";
-
-export const radixWallet = createWallet({
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectRadixWallet(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const radixConfig = SKConfig.get("integrations").radix;
-
-      if (!radixConfig) {
-        throw new SwapKitError("wallet_radix_not_found");
-      }
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const walletMethods = await getWalletMethods();
-
-          addChain({ ...walletMethods, chain, walletType });
-        }),
-      );
-
-      return true;
-    },
-  name: "connectRadixWallet",
-  supportedChains: [Chain.Radix],
-  walletType: WalletOption.RADIX_WALLET,
-});
-
-export const RADIX_SUPPORTED_CHAINS = getWalletSupportedChains(radixWallet);
-
-async function fetchFungibleResources(address: string): Promise<FungibleResourcesCollectionItem[]> {
-  const { GatewayApiClient } = await import("@radixdlt/babylon-gateway-api-sdk");
-  const { applicationName } = SKConfig.get("integrations").radix;
-  const networkApi = GatewayApiClient.initialize({ applicationName, networkId: 1 });
-
-  let hasNextPage = true;
-  let nextCursor: string | undefined;
-  let fungibleResources: FungibleResourcesCollectionItem[] = [];
-
-  const stateVersion = await currentStateVersion(networkApi);
-
-  while (hasNextPage) {
-    const stateEntityFungiblesPageRequest: StateEntityFungiblesPageRequest = {
-      address: address,
-      at_ledger_state: { state_version: stateVersion },
-      cursor: nextCursor,
-      limit_per_page: 100,
-    };
-
-    const stateEntityFungiblesPageResponse: StateEntityFungiblesPageResponse =
-      await networkApi.state.innerClient.entityFungiblesPage({
-        stateEntityFungiblesPageRequest: stateEntityFungiblesPageRequest,
-      });
-
-    fungibleResources = fungibleResources.concat(stateEntityFungiblesPageResponse.items);
-
-    if (stateEntityFungiblesPageResponse.next_cursor) {
-      nextCursor = stateEntityFungiblesPageResponse.next_cursor;
-    } else {
-      hasNextPage = false;
-    }
-  }
-  return fungibleResources;
-}
-
-function currentStateVersion(networkApi: GatewayApiClient) {
-  return networkApi.status.getCurrent().then((status) => status.ledger_state.state_version);
-}
-
-// TODO - @Towan: is that still needed with SwapKitApi.getChainBalance()?
-async function getBalance(address: string): Promise<AssetValue[]> {
-  const { GatewayApiClient } = await import("@radixdlt/babylon-gateway-api-sdk");
-  const resources = await fetchFungibleResources(address);
-  const { applicationName } = SKConfig.get("integrations").radix;
-  const networkApi = GatewayApiClient.initialize({ applicationName, networkId: 1 });
-
-  const balances: AssetValue[] = [];
-  const BATCH_SIZE = 50;
-
-  // Split resources into batches of up to 50 items
-  const resourceBatches: FungibleResourcesCollectionItem[][] = [];
-  for (let i = 0; i < resources.length; i += BATCH_SIZE) {
-    resourceBatches.push(resources.slice(i, i + BATCH_SIZE));
-  }
-
-  for (const batch of resourceBatches) {
-    const addresses = batch.map((item) => item.resource_address);
-    const response: StateEntityDetailsVaultResponseItem[] =
-      await networkApi.state.getEntityDetailsVaultAggregated(addresses);
-
-    const divisibilities = new Map<string, { decimals: number; symbol: string }>();
-
-    for (const result of response) {
-      if (result.details !== undefined) {
-        const metaDataSymbol = result.metadata?.items.find((item) => item.key === "symbol");
-        const symbol = metaDataSymbol?.value.typed.type === "String" ? metaDataSymbol.value.typed.value : "?";
-
-        if (result.details.type === "FungibleResource") {
-          divisibilities.set(result.address, { decimals: result.details.divisibility, symbol });
-        }
-      }
-    }
-
-    for (const item of batch) {
-      if (item.aggregation_level === "Global") {
-        const assetInfo = divisibilities.get(item.resource_address) || { decimals: 0, symbol: "?" };
-
-        const balance = AssetValue.from({
-          asset:
-            assetInfo.symbol !== Chain.Radix
-              ? `${Chain.Radix}.${assetInfo.symbol}-${item.resource_address}`
-              : "XRD.XRD",
-          value: item.amount,
-        });
-        balances.push(balance);
-      }
-    }
-  }
-
-  const hasNativeAsset = balances.some((asset) => asset.isGasAsset);
-  if (!hasNativeAsset) {
-    return [AssetValue.from({ chain: Chain.Radix }), ...balances];
-  }
-
-  return balances;
-}
-
-async function getWalletMethods() {
-  const { RadixDappToolkit } = await import("@radixdlt/radix-dapp-toolkit");
-  const dappConfig = SKConfig.get("integrations").radix;
-  const rdt = RadixDappToolkit({ ...dappConfig, networkId: dappConfig.network.networkId });
-
-  function delay(ms: number) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  // TODO: @Towan - Wat is dat?
-  await delay(400);
-
-  function getAddress() {
-    const existingWalletData = rdt.walletApi.getWalletData();
-    const account = existingWalletData?.accounts?.[0];
-
-    return account?.address;
-  }
-
-  const getNewAddress = async () => {
-    const { DataRequestBuilder } = await import("@radixdlt/radix-dapp-toolkit");
-    rdt.walletApi.setRequestData(DataRequestBuilder.accounts().exactly(1));
-    const res = await rdt.walletApi.sendRequest();
-
-    if (!res) {
-      throw new SwapKitError("wallet_radix_no_account");
-    }
-
-    const newAddress = res.unwrapOr(null)?.accounts[0]?.address;
-
-    if (!newAddress) {
-      throw new SwapKitError("wallet_radix_no_account");
-    }
-
-    return newAddress;
-  };
-
-  const address = getAddress() || (await getNewAddress());
-
-  return {
-    address,
-    getAddress,
-    getBalance: () => getBalance(address),
-    radixDappToolkit: rdt,
-    signAndBroadcast: async ({ manifest, message }: { manifest: string; message: string }) => {
-      const tx = await rdt.walletApi.sendTransaction({ message, transactionManifest: manifest });
-
-      const txResult = tx.unwrapOr(null)?.transactionIntentHash;
-
-      if (!txResult) {
-        throw new SwapKitError("wallet_radix_transaction_failed");
-      }
-
-      return txResult;
-    },
-    transfer: (_params: { assetValue: AssetValue; recipient: string; from: string }) => {
-      throw new SwapKitError("wallet_radix_method_not_supported", { method: "transfer" });
-    },
-  };
-}

package/src/talisman.ts

@@ -1 +0,0 @@
-export * from "@swapkit/wallet-extensions/talisman";

package/src/trezor.ts

@@ -1 +0,0 @@
-export * from "@swapkit/wallet-hardware/trezor";

package/src/tronlink.ts

@@ -1 +0,0 @@
-export * from "@swapkit/wallet-extensions/tronlink";

package/src/types.ts

@@ -1,94 +0,0 @@
-import { WalletOption } from "@swapkit/helpers";
-import type { bitgetWallet } from "@swapkit/wallet-extensions/bitget";
-import type { cosmostationWallet } from "@swapkit/wallet-extensions/cosmostation";
-import type { ctrlWallet } from "@swapkit/wallet-extensions/ctrl";
-import type { evmWallet } from "@swapkit/wallet-extensions/evm-extensions";
-import type { keepkeyBexWallet } from "@swapkit/wallet-extensions/keepkey-bex";
-import type { keplrWallet } from "@swapkit/wallet-extensions/keplr";
-import type { okxWallet } from "@swapkit/wallet-extensions/okx";
-import type { onekeyWallet } from "@swapkit/wallet-extensions/onekey";
-import type { phantomWallet } from "@swapkit/wallet-extensions/phantom";
-import type { polkadotWallet } from "@swapkit/wallet-extensions/polkadotjs";
-import type { talismanWallet } from "@swapkit/wallet-extensions/talisman";
-import type { tronlinkWallet } from "@swapkit/wallet-extensions/tronlink";
-import type { vultisigWallet } from "@swapkit/wallet-extensions/vultisig";
-import type { keepkeyWallet } from "@swapkit/wallet-hardware/keepkey";
-import type { ledgerWallet } from "@swapkit/wallet-hardware/ledger";
-import type { trezorWallet } from "@swapkit/wallet-hardware/trezor";
-import type { coinbaseWallet } from "./coinbase";
-import type { keystoreWallet } from "./keystore";
-import type { walletSelectorWallet } from "./near-wallet-selector";
-import type { passkeysWallet } from "./passkeys";
-import type { radixWallet } from "./radix";
-import type { walletconnectWallet } from "./walletconnect";
-import type { xamanWallet } from "./xaman";
-
-export type SKWallets = {
-  [WalletOption.BITGET]: typeof bitgetWallet;
-  [WalletOption.BRAVE]: typeof evmWallet;
-  [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet;
-  [WalletOption.COINBASE_WEB]: typeof evmWallet;
-  [WalletOption.COSMOSTATION]: typeof cosmostationWallet;
-  [WalletOption.CTRL]: typeof ctrlWallet;
-  [WalletOption.EIP6963]: typeof evmWallet;
-  [WalletOption.EXODUS]: typeof passkeysWallet;
-  [WalletOption.KEEPKEY]: typeof keepkeyWallet;
-  [WalletOption.KEEPKEY_BEX]: typeof keepkeyBexWallet;
-  [WalletOption.KEPLR]: typeof keplrWallet;
-  [WalletOption.KEYSTORE]: typeof keystoreWallet;
-  [WalletOption.LEAP]: typeof keplrWallet;
-  [WalletOption.LEDGER]: typeof ledgerWallet;
-  [WalletOption.LEDGER_LIVE]: typeof ledgerWallet;
-  [WalletOption.METAMASK]: typeof evmWallet;
-  [WalletOption.OKX]: typeof okxWallet;
-  [WalletOption.OKX_MOBILE]: typeof evmWallet;
-  [WalletOption.ONEKEY]: typeof onekeyWallet;
-  [WalletOption.PASSKEYS]: typeof passkeysWallet;
-  [WalletOption.PHANTOM]: typeof phantomWallet;
-  [WalletOption.POLKADOT_JS]: typeof polkadotWallet;
-  [WalletOption.RADIX_WALLET]: typeof radixWallet;
-  [WalletOption.TALISMAN]: typeof talismanWallet;
-  [WalletOption.TREZOR]: typeof trezorWallet;
-  [WalletOption.TRONLINK]: typeof tronlinkWallet;
-  [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet;
-  [WalletOption.VULTISIG]: typeof vultisigWallet;
-  [WalletOption.WALLETCONNECT]: typeof walletconnectWallet;
-  [WalletOption.WALLET_SELECTOR]: typeof walletSelectorWallet;
-  [WalletOption.XAMAN]: typeof xamanWallet;
-};
-
-export type SKConnectWallets = SKWallets[keyof SKWallets];
-
-export type SKWalletsSupportedChains = {
-  [WalletOption.BITGET]: typeof bitgetWallet.connectBitget.supportedChains;
-  [WalletOption.BRAVE]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet.connectCoinbaseWallet.supportedChains;
-  [WalletOption.COINBASE_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.COSMOSTATION]: typeof cosmostationWallet.connectCosmostation.supportedChains;
-  [WalletOption.CTRL]: typeof ctrlWallet.connectCtrl.supportedChains;
-  [WalletOption.EIP6963]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.EXODUS]: typeof passkeysWallet.connectPasskeys.supportedChains;
-  [WalletOption.KEEPKEY]: typeof keepkeyWallet.connectKeepkey.supportedChains;
-  [WalletOption.KEEPKEY_BEX]: typeof keepkeyBexWallet.connectKeepkeyBex.supportedChains;
-  [WalletOption.KEPLR]: typeof keplrWallet.connectKeplr.supportedChains;
-  [WalletOption.KEYSTORE]: typeof keystoreWallet.connectKeystore.supportedChains;
-  [WalletOption.LEAP]: typeof keplrWallet.connectKeplr.supportedChains;
-  [WalletOption.LEDGER]: typeof ledgerWallet.connectLedger.supportedChains;
-  [WalletOption.LEDGER_LIVE]: typeof ledgerWallet.connectLedger.supportedChains;
-  [WalletOption.METAMASK]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.OKX]: typeof okxWallet.connectOkx.supportedChains;
-  [WalletOption.OKX_MOBILE]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.ONEKEY]: typeof onekeyWallet.connectOnekeyWallet.supportedChains;
-  [WalletOption.PASSKEYS]: typeof passkeysWallet.connectPasskeys.supportedChains;
-  [WalletOption.PHANTOM]: typeof phantomWallet.connectPhantom.supportedChains;
-  [WalletOption.POLKADOT_JS]: typeof polkadotWallet.connectPolkadotJs.supportedChains;
-  [WalletOption.RADIX_WALLET]: typeof radixWallet.connectRadixWallet.supportedChains;
-  [WalletOption.TALISMAN]: typeof talismanWallet.connectTalisman.supportedChains;
-  [WalletOption.TREZOR]: typeof trezorWallet.connectTrezor.supportedChains;
-  [WalletOption.TRONLINK]: typeof tronlinkWallet.connectTronLink.supportedChains;
-  [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
-  [WalletOption.VULTISIG]: typeof vultisigWallet.connectVultisig.supportedChains;
-  [WalletOption.WALLETCONNECT]: typeof walletconnectWallet.connectWalletconnect.supportedChains;
-  [WalletOption.WALLET_SELECTOR]: typeof walletSelectorWallet.connectWalletSelector.supportedChains;
-  [WalletOption.XAMAN]: typeof xamanWallet.connectXaman.supportedChains;
-};

package/src/utils.ts

@@ -1,59 +0,0 @@
-import { WalletOption } from "@swapkit/helpers";
-import type { SKWallets } from "./types";
-
-export async function loadWallet<W extends WalletOption>(walletOption: W): Promise<SKWallets[W]> {
-  const { match } = await import("ts-pattern");
-
-  const wallet = await match(walletOption as WalletOption)
-    .with(WalletOption.COINBASE_MOBILE, async () => (await import("./coinbase")).coinbaseWallet)
-    .with(WalletOption.BITGET, async () => (await import("@swapkit/wallet-extensions/bitget")).bitgetWallet)
-    .with(WalletOption.CTRL, async () => (await import("@swapkit/wallet-extensions/ctrl")).ctrlWallet)
-    .with(WalletOption.VULTISIG, async () => (await import("@swapkit/wallet-extensions/vultisig")).vultisigWallet)
-    .with(WalletOption.OKX, async () => (await import("@swapkit/wallet-extensions/okx")).okxWallet)
-    .with(WalletOption.ONEKEY, async () => (await import("@swapkit/wallet-extensions/onekey")).onekeyWallet)
-    .with(WalletOption.EXODUS, async () => (await import("./passkeys")).passkeysWallet)
-    .with(WalletOption.KEEPKEY, async () => (await import("@swapkit/wallet-hardware/keepkey")).keepkeyWallet)
-    .with(
-      WalletOption.KEEPKEY_BEX,
-      async () => (await import("@swapkit/wallet-extensions/keepkey-bex")).keepkeyBexWallet,
-    )
-    .with(WalletOption.WALLETCONNECT, async () => (await import("./walletconnect")).walletconnectWallet)
-    .with(
-      WalletOption.KEPLR,
-      WalletOption.LEAP,
-      async () => (await import("@swapkit/wallet-extensions/keplr")).keplrWallet,
-    )
-    .with(
-      WalletOption.COSMOSTATION,
-      async () => (await import("@swapkit/wallet-extensions/cosmostation")).cosmostationWallet,
-    )
-    .with(
-      WalletOption.BRAVE,
-      WalletOption.COINBASE_WEB,
-      WalletOption.EIP6963,
-      WalletOption.METAMASK,
-      WalletOption.OKX_MOBILE,
-      WalletOption.TRUSTWALLET_WEB,
-      async () => (await import("@swapkit/wallet-extensions/evm-extensions")).evmWallet,
-    )
-
-    .with(WalletOption.KEYSTORE, async () => (await import("@swapkit/wallet-keystore")).keystoreWallet)
-    .with(WalletOption.TREZOR, async () => (await import("@swapkit/wallet-hardware/trezor")).trezorWallet)
-    .with(
-      WalletOption.LEDGER,
-      // TODO: Remove
-      WalletOption.LEDGER_LIVE,
-      async () => (await import("@swapkit/wallet-hardware/ledger")).ledgerWallet,
-    )
-    .with(WalletOption.PASSKEYS, async () => (await import("./passkeys")).passkeysWallet)
-    .with(WalletOption.PHANTOM, async () => (await import("@swapkit/wallet-extensions/phantom")).phantomWallet)
-    .with(WalletOption.POLKADOT_JS, async () => (await import("@swapkit/wallet-extensions/polkadotjs")).polkadotWallet)
-    .with(WalletOption.RADIX_WALLET, async () => (await import("./radix")).radixWallet)
-    .with(WalletOption.TALISMAN, async () => (await import("@swapkit/wallet-extensions/talisman")).talismanWallet)
-    .with(WalletOption.TRONLINK, async () => (await import("@swapkit/wallet-extensions/tronlink")).tronlinkWallet)
-    .with(WalletOption.WALLET_SELECTOR, async () => (await import("./near-wallet-selector")).walletSelectorWallet)
-    .with(WalletOption.XAMAN, async () => (await import("./xaman")).xamanWallet)
-    .exhaustive();
-
-  return wallet as SKWallets[W];
-}

package/src/vultisig.ts

@@ -1 +0,0 @@
-export * from "@swapkit/wallet-extensions/vultisig";

package/src/walletconnect/constants.ts

@@ -1,103 +0,0 @@
-import type { ClientMetadata } from "./types";
-
-export const DEFAULT_RELAY_URL = "wss://relay.walletconnect.com";
-
-export const ETHEREUM_MAINNET_ID = "eip155:1";
-export const BSC_MAINNET_ID = "eip155:56";
-export const AVALANCHE_MAINNET_ID = "eip155:43114";
-export const THORCHAIN_MAINNET_ID = "cosmos:thorchain";
-export const COSMOS_HUB_MAINNET_ID = "cosmos:cosmoshub-4";
-export const KUJIRA_MAINNET_ID = "cosmos:kaiyo-1";
-export const MAYACHAIN_MAINNET_ID = "cosmos:mayachain-mainnet-v1";
-export const ARBITRUM_ONE_MAINNET_ID = "eip155:42161";
-export const OPTIMISM_MAINNET_ID = "eip155:10";
-export const POLYGON_MAINNET_ID = "eip155:137";
-export const BASE_MAINNET_ID = "eip155:8453";
-export const NEAR_MAINNET_ID = "near:mainnet";
-export const NEAR_TESTNET_ID = "near:testnet";
-export const TRON_MAINNET_ID = "tron:0x2b6653dc";
-export const AURORA_MAINNET_ID = "eip155:1313161554";
-export const BERACHAIN_MAINNET_ID = "eip155:80094";
-export const MONAD_MAINNET_ID = "eip155:143";
-
-export const DEFAULT_LOGGER = "debug";
-
-export const DEFAULT_APP_METADATA: ClientMetadata = {
-  description: "SwapKit cross-chain SDK",
-  icons: ["https://raw.githubusercontent.com/swapkit/SwapKit/refs/heads/develop/docs/src/assets/logo-black.png"],
-  name: "SwapKit",
-  url: "https://swapkit.dev/",
-};
-
-/**
- * EIP155
- */
-export enum DEFAULT_EIP155_METHODS {
-  ETH_SEND_TRANSACTION = "eth_sendTransaction",
-  // not supported by most WC wallets
-  // ETH_SIGN_TRANSACTION = 'eth_signTransaction',
-  ETH_SIGN = "eth_sign",
-  PERSONAL_SIGN = "personal_sign",
-  ETH_SIGN_TYPED_DATA = "eth_signTypedData",
-}
-
-export enum DEFAULT_EIP_155_EVENTS {
-  ETH_CHAIN_CHANGED = "chainChanged",
-  ETH_ACCOUNTS_CHANGED = "accountsChanged",
-}
-
-/**
- * COSMOS
- */
-export enum DEFAULT_COSMOS_METHODS {
-  COSMOS_SIGN_DIRECT = "cosmos_signDirect",
-  COSMOS_SIGN_AMINO = "cosmos_signAmino",
-  COSMOS_GET_ACCOUNTS = "cosmos_getAccounts",
-}
-
-export enum DEFAULT_COSMOS_EVENTS {}
-
-/**
- * SOLANA
- */
-export enum DEFAULT_SOLANA_METHODS {
-  SOL_SIGN_TRANSACTION = "solana_signTransaction",
-  SOL_SIGN_MESSAGE = "solana_signMessage",
-}
-
-export enum DEFAULT_SOLANA_EVENTS {}
-
-/**
- * POLKADOT
- */
-export enum DEFAULT_POLKADOT_METHODS {
-  POLKADOT_SIGN_TRANSACTION = "polkadot_signTransaction",
-  POLKADOT_SIGN_MESSAGE = "polkadot_signMessage",
-}
-
-export enum DEFAULT_POLKADOT_EVENTS {}
-
-/**
- * NEAR
- */
-export enum DEFAULT_NEAR_METHODS {
-  NEAR_SIGN_IN = "near_signIn",
-  NEAR_SIGN_OUT = "near_signOut",
-  NEAR_GET_ACCOUNTS = "near_getAccounts",
-  NEAR_SIGN_AND_SEND_TRANSACTION = "near_signAndSendTransaction",
-  NEAR_SIGN_AND_SEND_TRANSACTIONS = "near_signAndSendTransactions",
-}
-
-export enum DEFAULT_NEAR_EVENTS {}
-
-/**
- * TRON
- */
-export enum DEFAULT_TRON_METHODS {
-  TRON_SIGN_MESSAGE = "tron_signMessage",
-  TRON_SIGN_TRANSACTION = "tron_signTransaction",
-  TRON_SEND_TRANSACTION = "tron_sendTransaction",
-  TRON_GET_ACCOUNTS = "tron_getAccounts",
-}
-
-export enum DEFAULT_TRON_EVENTS {}

package/src/walletconnect/evmSigner.ts

@@ -1,125 +0,0 @@
-import { type EVMChain, SwapKitError, WalletOption } from "@swapkit/helpers";
-import type { JsonRpcProvider, Provider, TransactionRequest, TransactionResponse } 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}`;
-  };
-
-  // ANCHOR (@Towan) - Implement in future
-  signTypedData = () => {
-    throw new SwapKitError("wallet_walletconnect_method_not_supported", { method: "signTypedData" });
-
-    // const { toHexString } = await import('@swapkit/toolboxes/evm');
-
-    // const baseTx = {
-    //   from,
-    //   to,
-    //   value: toHexString(value || 0n),
-    //   data,
-    // };
-
-    // const txHash = (await this.walletconnect?.client.request({
-    //   chainId: chainToChainId(this.chain),
-    //   topic: this.walletconnect.session.topic,
-    //   request: {
-    //     method: DEFAULT_EIP155_METHODS.ETH_SIGN_TYPED_DATA,
-    //     params: [baseTx],
-    //   },
-    // })) as string;
-
-    // return txHash.startsWith('0x') ? txHash : `0x${txHash}`;
-  };
-
-  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

@@ -1,73 +0,0 @@
-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,
-} 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;
-    default:
-      return "";
-  }
-};