@swapkit/helpers 1.0.0-rc.112 → 1.0.0-rc.114

package/package.json

@@ -2,17 +2,8 @@
   "author": "swapkit-oss",
   "description": "SwapKit - Helpers",
   "dependencies": {
-    "ky": "1.2.3",
-    "zod": "3.23.8"
-  },
-  "devDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.54",
-    "bun-types": "1.1.8",
-    "ethers": "6.11.1"
-  },
-  "peerDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.54",
-    "ky": "1.2.3",
+    "@swapkit/tokens": "1.0.0-rc.56",
+    "ky": "1.3.0",
     "zod": "3.23.8"
   },
   "files": [
@@ -30,13 +21,13 @@
   },
   "scripts": {
     "build": "bun run ./build.ts",
-    "clean": "rm -rf .turbo dist node_modules *.tsbuildinfo",
-    "lint": "biome check --apply ./src",
+    "clean": "rm -rf dist node_modules *.tsbuildinfo",
+    "lint": "biome check --write ./src",
     "test": "bun test",
-    "test:coverage": "echo 'bun test --coverage'",
+    "test:coverage": "bun test --coverage",
     "type-check": "tsc --noEmit"
   },
   "type": "module",
   "types": "./src/index.ts",
-  "version": "1.0.0-rc.112"
+  "version": "1.0.0-rc.114"
 }

package/src/helpers/__tests__/memo.test.ts

@@ -1,91 +1,72 @@
 import { describe, expect, test } from "bun:test";
 import { Chain, MemoType } from "../../types";
 
-import { getMemoFor } from "../memo.ts";
+import {
+  getMemoForDeposit,
+  getMemoForLeaveAndBond,
+  getMemoForNameRegister,
+  getMemoForSaverDeposit,
+  getMemoForSaverWithdraw,
+  getMemoForWithdraw,
+} from "../memo.ts";
 
-describe("getMemoFor", () => {
-  describe("for Leave, Upgrade, and Bond", () => {
-    const nodeMemos = [
-      [MemoType.LEAVE, "LEAVE:ABC123"],
-      [MemoType.BOND, "BOND:ABC123"],
-    ];
-
-    for (const [memoType, expected = ""] of nodeMemos) {
-      test(`returns correct memo for ${memoType}`, () => {
-        const result = getMemoFor(memoType as MemoType, { address: "ABC123" });
-        expect(result).toBe(expected);
-      });
-    }
+describe("getMemoForSaverDeposit", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForSaverDeposit({ chain: Chain.Ethereum, symbol: "ETH" });
+    expect(result).toBe("+:ETH/ETH");
   });
+});
 
-  describe("for Unbond and Thorname/Mayaname Register", () => {
-    test("returns correct memo for Unbond", () => {
-      const result = getMemoFor(MemoType.UNBOND, { address: "ABC123", unbondAmount: 1000000000 });
-      expect(result).toBe("UNBOND:ABC123:1000000000");
-    });
-
-    test("returns correct memo for Thorname Register", () => {
-      const result = getMemoFor(MemoType.NAME_REGISTER, {
-        name: "thorname",
-        chain: "BNB",
-        address: "0xABC123",
-        owner: "0xDEF456",
-      });
-      expect(result).toBe("~:thorname:BNB:0xABC123:0xDEF456");
+describe("getMemoForSaverWithdraw", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForSaverWithdraw({
+      basisPoints: 5000,
+      chain: Chain.Ethereum,
+      symbol: "ETH",
     });
+    expect(result).toBe("-:ETH/ETH:5000");
+  });
+});
 
-    test("returns correct memo for Mayaname Register", () => {
-      const result = getMemoFor(MemoType.NAME_REGISTER, {
-        name: "mayaname",
-        chain: "BNB",
-        address: "0xABC123",
-        owner: "0xDEF456",
-      });
-      expect(result).toBe("~:mayaname:BNB:0xABC123:0xDEF456");
-    });
+describe("getMemoForLeaveAndBond", () => {
+  test("returns correct memo for Leave", () => {
+    const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.LEAVE });
+    expect(result).toBe("LEAVE:ABC123");
   });
 
-  describe("for Deposit", () => {
-    test("returns correct memo for Deposit (single side)", () => {
-      const result = getMemoFor(MemoType.DEPOSIT, {
-        chain: Chain.Ethereum,
-        symbol: "ETH",
-        singleSide: true,
-      });
-      expect(result).toBe("+:ETH/ETH");
-    });
+  test("returns correct memo for Bond", () => {
+    const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.BOND });
+    expect(result).toBe("BOND:ABC123");
+  });
+});
 
-    test("returns correct memo for Deposit (dual side)", () => {
-      const result = getMemoFor(MemoType.DEPOSIT, {
-        chain: Chain.Avalanche,
-        symbol: "AVAX",
-        address: "0xABC123",
-      });
-      expect(result).toBe("+:AVAX.AVAX:0xABC123");
+describe("getMemoForNameRegister", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForNameRegister({
+      name: "asdfg",
+      chain: Chain.Ethereum,
+      owner: "thor1234",
+      address: "0xaasd123",
     });
+    expect(result).toBe("~:asdfg:ETH:0xaasd123:thor1234");
   });
+});
 
-  describe("for Withdraw", () => {
-    test("returns correct memo for Withdraw (single side)", () => {
-      const result = getMemoFor(MemoType.WITHDRAW, {
-        chain: Chain.Bitcoin,
-        ticker: "BTC",
-        symbol: "BTC",
-        basisPoints: 10000,
-        singleSide: true,
-      });
-      expect(result).toBe("-:BTC/BTC:10000");
-    });
+describe("getMemoForDeposit", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForDeposit({ chain: Chain.Ethereum, symbol: "ETH" });
+    expect(result).toBe("+:ETH.ETH");
+  });
+});
 
-    test("returns correct memo for Withdraw (dual side)", () => {
-      const result = getMemoFor(MemoType.WITHDRAW, {
-        chain: Chain.Ethereum,
-        ticker: "ETH",
-        symbol: "ETH",
-        basisPoints: 100,
-        targetAssetString: "ETH.ETH",
-      });
-      expect(result).toBe("-:ETH.ETH:100:ETH.ETH");
+describe("getMemoForWithdraw", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForWithdraw({
+      chain: Chain.Ethereum,
+      symbol: "ETH",
+      ticker: "ETH",
+      basisPoints: 100,
     });
+    expect(result).toBe("-:ETH.ETH:100");
   });
 });

package/src/helpers/memo.ts

@@ -1,17 +1,130 @@
 import { Chain } from "../types/chains";
 import { MemoType } from "../types/sdk";
 
-export type NameRegisterParam = {
-  name: string;
-  chain: string;
-  address: string;
-  owner?: string;
-  preferredAsset?: string;
-  expiryBlock?: string;
-};
-
 type WithChain<T extends {}> = T & { chain: Chain };
 
+type WithAffiliate<T extends {}> = T & { affiliateAddress?: string; affiliateBasisPoints?: number };
+
+function addAffiliate(memo: string, { affiliateAddress, affiliateBasisPoints }: WithAffiliate<{}>) {
+  const affiliatePart = affiliateAddress ? `:${affiliateAddress}:${affiliateBasisPoints || 0}` : "";
+
+  return `${memo}${affiliatePart}`;
+}
+
+function getPoolIdentifier({ chain, symbol }: { chain: Chain; symbol: string }) {
+  switch (chain) {
+    case Chain.Bitcoin:
+    case Chain.Dogecoin:
+    case Chain.Litecoin:
+      return chain.slice(0, 1).toLowerCase();
+    case Chain.BitcoinCash:
+      return "c";
+
+    default:
+      return `${chain}.${symbol}`;
+  }
+}
+
+export function getMemoForLeaveAndBond({
+  type,
+  address,
+}: { type: MemoType.BOND | MemoType.LEAVE; address: string }) {
+  return `${type}:${address}`;
+}
+
+export function getMemoForUnbond({
+  address,
+  unbondAmount,
+}: { address: string; unbondAmount: number }) {
+  return `${MemoType.UNBOND}:${address}:${unbondAmount}`;
+}
+
+export function getMemoForNameRegister({
+  name,
+  chain,
+  address,
+  owner,
+}: { name: string; chain: string; address: string; owner?: string }) {
+  const baseMemo = `${MemoType.NAME_REGISTER}:${name}:${chain}:${address}`;
+  const ownerAssignmentOrChangePart = owner ? `:${owner}` : "";
+
+  return `${baseMemo}${ownerAssignmentOrChangePart}`;
+}
+
+export function getMemoForLoan(
+  memoType: MemoType.OPEN_LOAN | MemoType.CLOSE_LOAN,
+  {
+    asset,
+    address,
+    minAmount,
+    ...affiliate
+  }: WithAffiliate<{
+    address: string;
+    asset: string;
+    minAmount?: string;
+  }>,
+) {
+  const baseMemo = `${memoType}:${asset}:${address}`;
+  const minAmountPart = minAmount ? `:${minAmount}` : "";
+
+  return addAffiliate(`${baseMemo}${minAmountPart}`, affiliate);
+}
+
+export function getMemoForSaverDeposit({
+  chain,
+  symbol,
+  ...affiliate
+}: WithAffiliate<{ chain: Chain; symbol: string }>) {
+  return addAffiliate(`${MemoType.DEPOSIT}:${chain}/${symbol}`, affiliate);
+}
+
+export function getMemoForDeposit({
+  chain,
+  symbol,
+  address,
+}: { chain: Chain; symbol: string; address?: string }) {
+  const poolIdentifier = getPoolIdentifier({ chain, symbol });
+  const addressPart = address ? `:${address}` : "";
+
+  return `${MemoType.DEPOSIT}:${poolIdentifier}${addressPart}`;
+}
+
+export function getMemoForSaverWithdraw({
+  chain,
+  symbol,
+  basisPoints,
+  ...affiliate
+}: WithAffiliate<{ chain: Chain; symbol: string; basisPoints: number }>) {
+  return addAffiliate(`${MemoType.WITHDRAW}:${chain}/${symbol}:${basisPoints}`, affiliate);
+}
+
+export function getMemoForWithdraw({
+  chain,
+  symbol,
+  ticker,
+  basisPoints,
+  targetAsset,
+  ...affiliate
+}: WithAffiliate<{
+  chain: Chain;
+  symbol: string;
+  ticker: string;
+  basisPoints: number;
+  targetAsset?: string;
+}>) {
+  const shortenedSymbol =
+    chain === "ETH" && ticker !== "ETH" ? `${ticker}-${symbol.slice(-3)}` : symbol;
+  const targetPart = targetAsset ? `:${targetAsset}` : "";
+
+  return addAffiliate(
+    `${MemoType.WITHDRAW}:${chain}.${shortenedSymbol}:${basisPoints}${targetPart}`,
+    affiliate,
+  );
+}
+
+/**
+ * @deprecated - Use separate functions per each memo type like getMemoForDeposit, getMemoForWithdraw, etc.
+ */
 export type MemoOptions<T extends MemoType> = {
   [MemoType.BOND]: { address: string };
   [MemoType.LEAVE]: { address: string };
@@ -26,68 +139,62 @@ export type MemoOptions<T extends MemoType> = {
     targetAssetString?: string;
     singleSide?: boolean;
   }>;
-  [MemoType.NAME_REGISTER]: Omit<NameRegisterParam, "preferredAsset" | "expiryBlock">;
+  [MemoType.NAME_REGISTER]: { name: string; chain: string; address: string };
 }[T];
 
+/**
+ * @deprecated - Use separate functions per each memo type like getMemoForDeposit, getMemoForWithdraw, etc.
+ */
 export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions<T>) => {
   switch (memoType) {
     case MemoType.LEAVE:
     case MemoType.BOND: {
       const { address } = options as MemoOptions<MemoType.BOND>;
-      return `${memoType}:${address}`;
+      return getMemoForLeaveAndBond({ type: memoType, address });
     }
 
     case MemoType.UNBOND: {
       const { address, unbondAmount } = options as MemoOptions<MemoType.UNBOND>;
-      return `${memoType}:${address}:${unbondAmount}`;
+      return getMemoForUnbond({ address, unbondAmount });
     }
 
     case MemoType.NAME_REGISTER: {
-      const { name, chain, address, owner } = options as MemoOptions<MemoType.NAME_REGISTER>;
-      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ""}`;
+      return getMemoForNameRegister(options as MemoOptions<MemoType.NAME_REGISTER>);
+    }
+
+    case MemoType.OPEN_LOAN:
+    case MemoType.CLOSE_LOAN: {
+      return getMemoForLoan(memoType, options as MemoOptions<MemoType.OPEN_LOAN>);
     }
 
     case MemoType.DEPOSIT: {
       const { chain, symbol, address, singleSide } = options as MemoOptions<MemoType.DEPOSIT>;
 
-      const getPoolIdentifier = (chain: Chain, symbol: string): string => {
-        switch (chain) {
-          case Chain.Litecoin:
-            return "l";
-          case Chain.Dogecoin:
-            return "d";
-          case Chain.BitcoinCash:
-            return "c";
-          default:
-            return `${chain}.${symbol}`;
-        }
-      };
-
-      return singleSide
-        ? `${memoType}:${chain}/${symbol}`
-        : `${memoType}:${getPoolIdentifier(chain, symbol)}:${address || ""}`;
+      if (singleSide) {
+        return getMemoForSaverDeposit({ chain, symbol });
+      }
+
+      return getMemoForDeposit({ chain, symbol, address });
     }
 
     case MemoType.WITHDRAW: {
-      const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } =
-        options as MemoOptions<MemoType.WITHDRAW>;
+      const {
+        chain,
+        ticker,
+        symbol,
+        basisPoints,
+        targetAssetString: targetAsset,
+        singleSide,
+      } = options as MemoOptions<MemoType.WITHDRAW>;
 
-      const shortenedSymbol =
-        chain === "ETH" && ticker !== "ETH" ? `${ticker}-${symbol.slice(-3)}` : symbol;
-      const target = !singleSide && targetAssetString ? `:${targetAssetString}` : "";
-      const assetDivider = singleSide ? "/" : ".";
-
-      return `${memoType}:${chain}${assetDivider}${shortenedSymbol}:${basisPoints}${target}`;
-    }
-
-    case MemoType.OPEN_LOAN:
-    case MemoType.CLOSE_LOAN: {
-      const { asset, address } = options as MemoOptions<MemoType.OPEN_LOAN>;
+      if (singleSide) {
+        return getMemoForSaverWithdraw({ chain, symbol, basisPoints });
+      }
 
-      return `${memoType}:${asset}:${address}`; //:${minAmount ? `${minAmount}` : ''}:t:0`;
+      return getMemoForWithdraw({ chain, ticker, symbol, basisPoints, targetAsset });
     }
 
     default:
-      return "";
+      throw new Error(`Unsupported memo type: ${memoType}`);
   }
 };

package/src/helpers/web3wallets.ts

@@ -13,6 +13,7 @@ export type EthereumWindowProvider = BrowserProvider & {
   isMetaMask?: boolean;
   isOkxWallet?: boolean;
   isTrust?: boolean;
+  isTalisman?: boolean;
   on: (event: string, callback?: () => void) => void;
   overrideIsMetaMask?: boolean;
   request: <T = unknown>(args: { method: string; params?: unknown[] }) => Promise<T>;

package/src/modules/assetValue.ts

@@ -177,6 +177,7 @@ export class AssetValue extends BigIntArithmetics {
 
   static fromChainOrSignature(assetString: CommonAssetString, value: NumberPrimitives = 0) {
     const { decimal, identifier } = getCommonAssetInfo(assetString);
+
     return new AssetValue({ value: safeValue(value, decimal), decimal, identifier });
   }
 

package/src/modules/bigIntArithmetics.ts

@@ -42,9 +42,7 @@ export function formatBigIntToSafeValue({
   // Check if we need to round up
   if (Number.parseInt(decimalString[bigIntDecimal] || "0") >= 5) {
     // Increment the last decimal place and slice off the rest
-    decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
-      Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1
-    ).toString()}`;
+    decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1).toString()}`;
   } else {
     // Just slice off the extra digits
     decimalString = decimalString.substring(0, bigIntDecimal);
@@ -277,9 +275,7 @@ export class BigIntArithmetics {
     // Check if we need to round up
     if (Number.parseInt(decimalString[bigIntDecimal] || "0") >= 5) {
       // Increment the last decimal place and slice off the rest
-      decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
-        Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1
-      ).toString()}`;
+      decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1).toString()}`;
     } else {
       // Just slice off the extra digits
       decimalString = decimalString.substring(0, bigIntDecimal);

package/src/modules/swapKitError.ts

@@ -11,7 +11,6 @@ const errorMessages = {
   core_plugin_swap_not_found: 10007,
   core_approve_asset_target_invalid: 10008,
   core_chain_halted: 10099,
-
   /**
    * Core - Wallet Connection
    */
@@ -39,12 +38,12 @@ const errorMessages = {
    * Core - Transaction
    */
   core_transaction_deposit_error: 10301,
-  core_transaction_create_liquidity_rune_error: 10302,
+  core_transaction_create_liquidity_base_error: 10302,
   core_transaction_create_liquidity_asset_error: 10303,
   core_transaction_create_liquidity_invalid_params: 10304,
   core_transaction_add_liquidity_invalid_params: 10305,
-  core_transaction_add_liquidity_no_rune_address: 10306,
-  core_transaction_add_liquidity_rune_error: 10307,
+  core_transaction_add_liquidity_base_address: 10306,
+  core_transaction_add_liquidity_base_error: 10307,
   core_transaction_add_liquidity_asset_error: 10308,
   core_transaction_withdraw_error: 10309,
   core_transaction_deposit_to_pool_error: 10310,
@@ -53,38 +52,37 @@ const errorMessages = {
   core_transaction_invalid_sender_address: 10313,
   core_transaction_deposit_server_error: 10314,
   core_transaction_user_rejected: 10315,
-  core_transaction_create_liquidity_cacao_error: 10316,
-  core_transaction_add_liquidity_no_cacao_address: 10306,
-  core_transaction_add_liquidity_cacao_error: 10307,
-
   /**
    * Wallets
    */
+  wallet_connection_rejected_by_user: 20000,
   wallet_ledger_connection_error: 20001,
   wallet_ledger_connection_claimed: 20002,
   wallet_ledger_get_address_error: 20003,
   wallet_ledger_device_not_found: 20004,
   wallet_ledger_device_locked: 20005,
-
+  wallet_phantom_not_found: 20101,
+  wallet_xdefi_not_found: 20201,
+  wallet_xdefi_failed_to_add_or_switch_network: 20202,
   /**
    * Chainflip
    */
   chainflip_channel_error: 30001,
   chainflip_broker_recipient_error: 30002,
-
   /**
    * THORChain
    */
-
+  thorchain_chain_halted: 40001,
+  thorchain_trading_halted: 40002,
   /**
    * SwapKit API
    */
-  api_v2_invalid_response: 40001,
+  api_v2_invalid_response: 50001,
 
   /**
    * Helpers
    */
-  helpers_number_different_decimals: 99101,
+  helpers_number_different_decimals: 99001,
 } as const;
 
 export type ErrorKeys = keyof typeof errorMessages;

package/src/types/chains.ts

@@ -20,6 +20,7 @@ export enum Chain {
   Polygon = "MATIC",
   Radix = "XRD",
   THORChain = "THOR",
+  Solana = "SOL",
 }
 
 export type WalletChain = Exclude<Chain, Chain.Chainflip | Chain.Radix>;
@@ -52,6 +53,7 @@ export enum ChainId {
   Radix = "radix-mainnet",
   THORChain = "thorchain-mainnet-v1",
   THORChainStagenet = "thorchain-stagenet-v2",
+  Solana = "solana",
 }
 
 export const ChainIdToChain: Record<ChainId, Chain> = {
@@ -82,6 +84,7 @@ export const ChainIdToChain: Record<ChainId, Chain> = {
   [ChainId.Radix]: Chain.Radix,
   [ChainId.THORChainStagenet]: Chain.THORChain,
   [ChainId.THORChain]: Chain.THORChain,
+  [ChainId.Solana]: Chain.Solana,
 };
 
 type ChainNameType = keyof typeof Chain;
@@ -106,9 +109,10 @@ export enum BaseDecimal {
   MATIC = 18,
   MAYA = 10,
   OP = 18,
+  SOL = 9,
   THOR = 8,
-  ZEC = 8,
   XRD = 18,
+  ZEC = 8,
 }
 
 export type SubstrateChain = Chain.Polkadot | Chain.Chainflip;

package/src/types/derivationPath.ts

@@ -27,8 +27,9 @@ export enum DerivationPath {
   MATIC = "m/44'/60'/0'/0",
   MAYA = "m/44'/931'/0'/0",
   OP = "m/44'/60'/0'/0",
-  XRD = "////",
+  SOL = "m/44'/501'/0'/0",
   THOR = "m/44'/931'/0'/0",
+  XRD = "////",
 }
 
 export type DerivationPathArray = [number, number, number, number, number?];
@@ -49,6 +50,7 @@ export const NetworkDerivationPath: Record<Chain, DerivationPathArray> = {
   MATIC: [44, 60, 0, 0, 0],
   MAYA: [44, 931, 0, 0, 0],
   OP: [44, 60, 0, 0, 0],
+  SOL: [44, 501, 0, 0, 0],
   THOR: [44, 931, 0, 0, 0],
 
   // Polkadot and related network derivation path is not number based

package/src/types/network.ts

@@ -20,6 +20,7 @@ export enum RPCUrl {
   Radix = "https://radix-mainnet.rpc.grove.city/v1/326002fc/core",
   THORChain = "https://rpc.thorswap.net",
   THORChainStagenet = "https://stagenet-rpc.ninerealms.com",
+  Solana = "https://mainnet.helius-rpc.com/?api-key=2cbe3ae6-cfc5-4141-a093-0055d0fa3d80",
 }
 
 export enum ExplorerUrl {
@@ -38,8 +39,9 @@ export enum ExplorerUrl {
   Litecoin = "https://blockchair.com/litecoin",
   Maya = "https://www.mayascan.org",
   Optimism = "https://optimistic.etherscan.io",
-  Polkadot = "https://polkadot.subscan.io/",
+  Polkadot = "https://polkadot.subscan.io",
   Polygon = "https://polygonscan.com",
   Radix = "https://dashboard.radixdlt.com",
   THORChain = "https://runescan.io",
+  Solana = "https://solscan.io",
 }

package/src/types/wallet.ts

@@ -9,23 +9,25 @@ declare global {
 }
 
 export enum WalletOption {
-  KEYSTORE = "KEYSTORE",
-  KEEPKEY = "KEEPKEY",
-  XDEFI = "XDEFI",
-  METAMASK = "METAMASK",
-  COINBASE_WEB = "COINBASE_WEB",
+  BRAVE = "BRAVE",
   COINBASE_MOBILE = "COINBASE_MOBILE",
-  TREZOR = "TREZOR",
-  TRUSTWALLET_WEB = "TRUSTWALLET_WEB",
-  LEDGER = "LEDGER",
+  COINBASE_WEB = "COINBASE_WEB",
+  EIP6963 = "EIP6963",
+  EXODUS = "EXODUS",
+  KEEPKEY = "KEEPKEY",
   KEPLR = "KEPLR",
+  KEYSTORE = "KEYSTORE",
+  LEDGER = "LEDGER",
+  METAMASK = "METAMASK",
   OKX = "OKX",
   OKX_MOBILE = "OKX_MOBILE",
-  BRAVE = "BRAVE",
-  WALLETCONNECT = "WALLETCONNECT",
-  EIP6963 = "EIP6963",
-  EXODUS = "EXODUS",
+  PHANTOM = "PHANTOM",
   RADIX_WALLET = "RADIX_WALLET",
+  TREZOR = "TREZOR",
+  TALISMAN = "TALISMAN",
+  TRUSTWALLET_WEB = "TRUSTWALLET_WEB",
+  WALLETCONNECT = "WALLETCONNECT",
+  XDEFI = "XDEFI",
 }
 
 export enum LedgerErrorCode {
@@ -43,10 +45,8 @@ export type ChainWallet = {
 };
 
 export type EmptyWallet = { [key in Chain]?: unknown };
-
-export type BaseWallet<T extends EmptyWallet | unknown> = {
-  // @ts-expect-error
-  [key in Chain]: ChainWallet & T[key];
+export type BaseWallet<T extends EmptyWallet | Record<string, unknown>> = {
+  [key in Chain]: ChainWallet & (T extends EmptyWallet ? T[key] : unknown);
 };
 
 export type EIP6963ProviderInfo = {