Connecting Wallets

Connecting Wallets with SwapKit

SwapKit provides multiple ways to connect wallets for different blockchain networks. This guide demonstrates how to connect various wallet types using both granular and all-in-one approaches.

Two Approaches to Using SwapKit

You can use SwapKit in two ways:

1. Granular approach - Import only what you need from individual packages:

   import { SwapKit } from "@swapkit/core";
   import { keystoreWallet } from "@swapkit/wallets/keystore";

2. All-in-one approach - Import everything from the SDK (better for backend/Node.js):

   import { createSwapKit } from "@swapkit/sdk";

The granular approach is recommended for frontend applications as it results in smaller bundle sizes.

Initialize SwapKit

Granular Approach (Frontend Recommended)

import { SwapKit } from "@swapkit/core";
import { keystoreWallet } from "@swapkit/wallets/keystore";
import { ledgerWallet } from "@swapkit/wallets/ledger";
import { evmWallet } from "@swapkit/wallets/evm-extensions";

// Initialize the SwapKit client with specific wallets
const swapKit = SwapKit({
  config: {
    apiKeys: {
      swapKit: "your-swapkit-api-key",
      walletConnectProjectId: "your-walletconnect-project-id",
    },
  },
  wallets: { ...keystoreWallet, ...ledgerWallet, ...evmWallet },
});

All-in-one Approach (Backend/Node.js)

import { createSwapKit } from "@swapkit/sdk";

// Initialize the SwapKit client with all wallets included
const swapKit = createSwapKit({
  config: {
    apiKeys: {
      swapKit: "your-swapkit-api-key",
      walletConnectProjectId: "your-walletconnect-project-id",
    },
  },
});

Connect with Keystore Wallet

Granular Approach

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { keystoreWallet } from "@swapkit/wallets/keystore";
import { decryptFromKeystore, type Keystore } from "@swapkit/wallets/keystore";

// Initialize SwapKit
const swapKit = SwapKit({
  wallets: { ...keystoreWallet },
});

// Connect with keystore
async function connectWithKeystore(
  keystoreFile: Keystore,
  password: string,
  chains: Chain[]
) {
  try {
    // Decrypt the keystore file
    const phrase = await decryptFromKeystore(keystoreFile, password);

    // Connect the chains with the decrypted phrase
    await swapKit.connectKeystore(chains, phrase);

    // Get wallet balances
    const balances = await Promise.all(
      chains.map(async (chain) => {
        const wallet = await swapKit.getWalletWithBalance(chain);
        return wallet.balance;
      })
    );

    return { success: true, balances };
  } catch (error) {
    return { success: false, error };
  }
}

All-in-one Approach

import { Chain } from "@swapkit/helpers";
import { createSwapKit } from "@swapkit/sdk";
import { decryptFromKeystore, type Keystore } from "@swapkit/wallets/keystore";

// Initialize SwapKit
const swapKit = createSwapKit();

// Connect with keystore
async function connectWithKeystore(
  keystoreFile: Keystore,
  password: string,
  chains: Chain[]
) {
  try {
    // Decrypt the keystore file
    const phrase = await decryptFromKeystore(keystoreFile, password);

    // Connect the chains with the decrypted phrase
    await swapKit.connectKeystore(chains, phrase);

    return { success: true };
  } catch (error) {
    return { success: false, error };
  }
}

Using Hardware Wallets

Ledger Wallet

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { ledgerWallet } from "@swapkit/wallets/ledger";

// Initialize SwapKit with Ledger wallet
const swapKit = SwapKit({
  wallets: { ...ledgerWallet },
});

// Connect Ledger wallet
async function connectLedger(chains: Chain[]) {
  try {
    // Connect to Ledger
    await swapKit.connectLedger(chains);

    // Get the wallet address for a specific chain
    const ethAddress = swapKit.getAddress(Chain.Ethereum);

    return { success: true };
  } catch (error) {
    return { success: false, error };
  }
}

Trezor Wallet

import { Chain, NetworkDerivationPath } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { trezorWallet } from "@swapkit/wallets/trezor";

// Initialize SwapKit with Trezor wallet
const swapKit = SwapKit({
  wallets: { ...trezorWallet },
});

// Connect Trezor wallet
async function connectTrezor(chains: Chain[]) {
  try {
    // Connect to Trezor
    await swapKit.connectTrezor([Chain.Bitcoin], NetworkDerivationPath.BTC);

    // Get wallet balances for Bitcoin
    const btcWallet = await swapKit.getWalletWithBalance(Chain.Bitcoin);

    return { success: true, balance: btcWallet.balance };
  } catch (error) {
    return { success: false, error };
  }
}

Using Browser Extension Wallets

MetaMask / EVM Wallets

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { evmWallet } from "@swapkit/wallets/evm-extensions";

// Initialize SwapKit
const swapKit = SwapKit({
  wallets: { ...evmWallet },
});

// Connect to MetaMask or other EVM wallets
async function connectEVMWallet() {
  try {
    // This will prompt the user to connect with their browser wallet
    await swapKit.connectEVMWallet([Chain.Ethereum, Chain.BinanceSmartChain]);

    // Get the Ethereum address
    const address = swapKit.getAddress(Chain.Ethereum);

    return { success: true, address };
  } catch (error) {
    return { success: false, error };
  }
}

Keplr (Cosmos) Wallet

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { keplrWallet } from "@swapkit/wallets/keplr";

// Initialize SwapKit
const swapKit = SwapKit({
  wallets: { ...keplrWallet },
});

// Connect to Keplr
async function connectKeplr() {
  try {
    await swapKit.connectKeplr([Chain.Cosmos]);

    // Get the Cosmos address
    const address = swapKit.getAddress(Chain.Cosmos);

    return { success: true, address };
  } catch (error) {
    return { success: false, error };
  }
}

Phantom (Solana) Wallet

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { phantomWallet } from "@swapkit/wallets/phantom";

// Initialize SwapKit
const swapKit = SwapKit({
  wallets: { ...phantomWallet },
});

// Connect to Phantom
async function connectPhantom() {
  try {
    await swapKit.connectPhantom([Chain.Solana]);

    // Get the Solana address
    const address = swapKit.getAddress(Chain.Solana);

    return { success: true, address };
  } catch (error) {
    return { success: false, error };
  }
}

Managing Wallet Connections

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { evmWallet } from "@swapkit/wallets/evm-extensions";

// Initialize SwapKit
const swapKit = SwapKit({
  wallets: { ...evmWallet },
});

// Get all connected wallets
function getAllWallets() {
  const wallets = swapKit.getAllWallets();
  return wallets;
}

// Disconnect a specific chain
function disconnectChain(chain: Chain) {
  swapKit.disconnectChain(chain);
}

// Disconnect all wallets
function disconnectAll() {
  swapKit.disconnectAll();
}

Getting Wallet Balances

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { evmWallet } from "@swapkit/wallets/evm-extensions";

// Initialize SwapKit
const swapKit = SwapKit({
  wallets: { ...evmWallet },
});

// Connect a wallet first
await swapKit.connectEVMWallet([Chain.Ethereum]);

// Get balance for a specific chain
async function getChainBalance(chain: Chain) {
  // Get the balance (true parameter refreshes the balance from the network)
  const balance = await swapKit.getBalance(chain, true);
  return balance;
}

// Get balances for multiple chains
async function getAllBalances(chains: Chain[]) {
  const balances = await Promise.all(
    chains.map(async (chain) => {
      try {
        const wallet = await swapKit.getWalletWithBalance(chain);
        return { chain, balance: wallet.balance };
      } catch (error) {
        return { chain, balance: [], error };
      }
    })
  );

  return balances;
}

Using WalletConnect

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { walletconnectWallet } from "@swapkit/wallets/walletconnect";

// Initialize SwapKit with WalletConnect
const swapKit = SwapKit({
  config: {
    apiKeys: {
      walletConnectProjectId: "YOUR_WALLETCONNECT_PROJECT_ID", // Required
    },
  },
  wallets: { ...walletconnectWallet },
});

// Connect using WalletConnect
async function connectWalletConnect() {
  try {
    await swapKit.connectWalletconnect([
      Chain.Ethereum,
      Chain.BinanceSmartChain,
      Chain.Cosmos,
    ]);

    // Check connected addresses
    const ethAddress = swapKit.getAddress(Chain.Ethereum);

    return { success: true };
  } catch (error) {
    return { success: false, error };
  }
}

Advanced: Connecting Multiple Wallets

import { Chain } from "@swapkit/helpers";
import { SwapKit } from "@swapkit/core";
import { evmWallet } from "@swapkit/wallets/evm-extensions";
import { keplrWallet } from "@swapkit/wallets/keplr";
import { keystoreWallet } from "@swapkit/wallets/keystore";

// Initialize SwapKit with multiple wallet types
const swapKit = SwapKit({
  wallets: { ...evmWallet, ...keplrWallet, ...keystoreWallet },
});

// Connect multiple wallet types
async function connectMultipleWallets(phrase: string) {
  try {
    // Connect EVM wallet for Ethereum
    await swapKit.connectEVMWallet([Chain.Ethereum]);

    // Connect Keplr for Cosmos
    await swapKit.connectKeplr([Chain.Cosmos]);

    // Connect keystore for Bitcoin
    await swapKit.connectKeystore([Chain.Bitcoin], phrase);

    // Get all connected wallets
    const wallets = swapKit.getAllWallets();

    // Get addresses for each chain
    const addresses = {
      [Chain.Ethereum]: swapKit.getAddress(Chain.Ethereum),
      [Chain.Cosmos]: swapKit.getAddress(Chain.Cosmos),
      [Chain.Bitcoin]: swapKit.getAddress(Chain.Bitcoin),
    };

    return { success: true, addresses };
  } catch (error) {
    return { success: false, error };
  }
}