@swapkit/wallets 4.0.0-beta.54 → 4.0.0-beta.56

package/src/keepkey/coins.ts

@@ -1,71 +0,0 @@
-/*
-    KeepKey Specific bip32 path conventions
-*/
-
-import { SwapKitError } from "@swapkit/helpers";
-
-const HARDENED = 0x80000000;
-
-export enum ChainToKeepKeyName {
-  BTC = "Bitcoin",
-  BCH = "BitcoinCash",
-  DOGE = "Dogecoin",
-  LTC = "Litecoin",
-  DASH = "Dash",
-  XRP = "Ripple",
-}
-
-export function addressNListToBIP32(address: number[]) {
-  return `m/${address.map((num) => (num >= HARDENED ? `${num - HARDENED}'` : num)).join("/")}`;
-}
-
-export function bip32Like(path: string) {
-  if (path === "m/") return true;
-
-  return /^m(((\/[0-9]+h)+|(\/[0-9]+H)+|(\/[0-9]+')*)((\/[0-9]+)*))$/.test(path);
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Refactor
-export function bip32ToAddressNList(initPath: string): number[] {
-  let path = initPath;
-
-  if (!bip32Like(path)) {
-    throw new SwapKitError("wallet_keepkey_invalid_params", {
-      reason: `Not a bip32 path: '${path}'`,
-    });
-  }
-
-  if (/^m\//i.test(path)) {
-    path = path.slice(2);
-  }
-  const segments = path.split("/");
-
-  if (segments.length === 1 && segments[0] === "") return [];
-
-  const ret = new Array(segments.length);
-
-  for (let i = 0; i < segments.length; i++) {
-    // TODO: Check for better way instead of exec
-    const segment = segments[i];
-    if (segment) {
-      const tmp = /(\d+)([hH']?)/.exec(segment);
-      if (tmp === null)
-        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid input" });
-
-      const [, num = "", modifier = ""] = tmp;
-
-      ret[i] = Number.parseInt(num, 10);
-
-      if (ret[i] >= HARDENED)
-        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid child index" });
-
-      if (modifier === "h" || modifier === "H" || modifier === "'") {
-        ret[i] += HARDENED;
-      } else if (modifier.length > 0) {
-        throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Invalid modifier" });
-      }
-    }
-  }
-
-  return ret;
-}

package/src/keepkey/index.ts

@@ -1,153 +0,0 @@
-import {
-  Chain,
-  type DerivationPathArray,
-  NetworkDerivationPath,
-  SKConfig,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} from "@swapkit/helpers";
-
-import { KeepKeySdk } from "@keepkey/keepkey-sdk";
-export type { PairingInfo } from "@keepkey/keepkey-sdk";
-
-import { getWalletSupportedChains } from "../utils";
-import { cosmosWalletMethods } from "./chains/cosmos";
-import { KeepKeySigner } from "./chains/evm";
-import { mayachainWalletMethods } from "./chains/mayachain";
-import { thorchainWalletMethods } from "./chains/thorchain";
-import { utxoWalletMethods } from "./chains/utxo";
-
-export const keepkeyWallet = createWallet({
-  name: "connectKeepkey",
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Cosmos,
-    Chain.Dogecoin,
-    Chain.Dash,
-    Chain.Ethereum,
-    Chain.Litecoin,
-    Chain.Ripple,
-    Chain.Optimism,
-    Chain.Polygon,
-    Chain.THORChain,
-    Chain.Maya,
-  ],
-  walletType: WalletOption.KEEPKEY,
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectKeepkey(
-      chains: Chain[],
-      derivationPathMap?: Record<Chain, DerivationPathArray>,
-    ) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const pairingInfo = SKConfig.get("integrations").keepKey;
-      if (!pairingInfo) throw new Error("KeepKey config not found");
-
-      const initialApiKey = SKConfig.get("apiKeys").keepKey || "1234";
-
-      await checkAndLaunch();
-
-      // Conform to the expected { apiKey, pairingInfo } structure
-      const keepkeyConfig = { apiKey: initialApiKey, pairingInfo };
-      const keepKeySdk = await KeepKeySdk.create(keepkeyConfig);
-
-      // Persist the new API key via SKConfig after pairing
-      if (keepkeyConfig.apiKey && keepkeyConfig.apiKey !== initialApiKey) {
-        SKConfig.setApiKey("keepKey", keepkeyConfig.apiKey);
-      }
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const walletMethods = await getWalletMethods({
-            chain,
-            derivationPath: derivationPathMap?.[chain] || NetworkDerivationPath[chain],
-            sdk: keepKeySdk,
-          });
-          const address = (await walletMethods.getAddress()) || "";
-
-          addChain({ ...walletMethods, address, chain, walletType: WalletOption.KEEPKEY });
-        }),
-      );
-      return true;
-    },
-});
-
-export const KEEPKEY_SUPPORTED_CHAINS = getWalletSupportedChains(keepkeyWallet);
-
-async function getWalletMethods({
-  sdk,
-  chain,
-  derivationPath,
-}: { sdk: KeepKeySdk; chain: Chain; derivationPath?: DerivationPathArray }) {
-  const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-
-  switch (chain) {
-    case Chain.BinanceSmartChain:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.Ethereum: {
-      const provider = await getProvider(chain);
-      const signer = new KeepKeySigner({ sdk, chain, derivationPath, provider });
-      const toolbox = await getEvmToolbox(chain, { provider, signer });
-
-      return toolbox;
-    }
-    case Chain.Cosmos: {
-      return cosmosWalletMethods({ sdk, derivationPath });
-    }
-    case Chain.THORChain: {
-      return thorchainWalletMethods({ sdk, derivationPath });
-    }
-    case Chain.Maya: {
-      return mayachainWalletMethods({ sdk, derivationPath });
-    }
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin: {
-      return utxoWalletMethods({ sdk, chain, derivationPath });
-    }
-    case Chain.Ripple: {
-      const { rippleWalletMethods } = await import("./chains/ripple");
-      return rippleWalletMethods({ sdk, derivationPath });
-    }
-    default:
-      throw new SwapKitError("wallet_keepkey_chain_not_supported", { chain });
-  }
-}
-
-// kk-sdk docs: https://keepkey.com/blog/building_on_the_keepkey_sdk
-// test spec: if offline, launch keepkey-bridge
-async function checkAndLaunch(attempts = 0) {
-  if (attempts >= 3) {
-    alert(
-      "KeepKey desktop is required for keepkey-sdk, please go to https://keepkey.com/get-started",
-    );
-  }
-  const isAvailable = await checkKeepkeyAvailability();
-
-  if (!isAvailable) {
-    window.location.assign("keepkey://launch");
-    await new Promise((resolve) => setTimeout(resolve, 30000));
-    checkAndLaunch(attempts + 1);
-  }
-}
-
-async function checkKeepkeyAvailability(spec = "http://localhost:1646/spec/swagger.json") {
-  try {
-    const response = await fetch(spec);
-    return response.status === 200;
-  } catch (_error) {
-    return false;
-  }
-}

package/src/keepkey-bex/index.ts

@@ -1,162 +0,0 @@
-import {
-  AssetValue,
-  Chain,
-  ChainIdToChain,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} from "@swapkit/helpers";
-import type { Eip1193Provider } from "ethers";
-import { getWalletSupportedChains } from "../utils";
-import {
-  type WalletTxParams,
-  getKEEPKEYAddress,
-  getKEEPKEYMethods,
-  getKEEPKEYProvider,
-  getProviderNameFromChain,
-  walletTransfer,
-} from "./walletHelpers";
-
-export const keepkeyBexWallet = createWallet({
-  name: "connectKeepkeyBex",
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Avalanche,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Base,
-    Chain.Cosmos,
-    Chain.Dash,
-    Chain.Dogecoin,
-    Chain.Ethereum,
-    Chain.Kujira,
-    Chain.Litecoin,
-    Chain.Maya,
-    Chain.Optimism,
-    Chain.Polygon,
-    Chain.Ripple,
-    Chain.Solana,
-    Chain.THORChain,
-  ],
-  walletType: WalletOption.KEEPKEY_BEX,
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectKeepkeyBex(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const address = await getKEEPKEYAddress(chain);
-          const walletMethods = await getWalletMethods(chain);
-
-          addChain({ ...walletMethods, address, chain, walletType });
-        }),
-      );
-
-      return true;
-    },
-});
-
-export const KEEPKEY_BEX_SUPPORTED_CHAINS = getWalletSupportedChains(keepkeyBexWallet);
-
-async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[number]) {
-  switch (chain) {
-    case Chain.Maya:
-    case Chain.THORChain: {
-      const { getCosmosToolbox, THORCHAIN_GAS_VALUE, MAYA_GAS_VALUE } = await import(
-        "@swapkit/toolboxes/cosmos"
-      );
-
-      const gasLimit = chain === Chain.Maya ? MAYA_GAS_VALUE : THORCHAIN_GAS_VALUE;
-      const toolbox = getCosmosToolbox(chain);
-
-      return {
-        ...toolbox,
-        deposit: (tx: WalletTxParams) => walletTransfer({ ...tx, recipient: "" }, "deposit"),
-        transfer: (tx: WalletTxParams) => walletTransfer({ ...tx, gasLimit }, "transfer"),
-      };
-    }
-
-    case Chain.Cosmos:
-    case Chain.Kujira: {
-      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
-
-      // @ts-expect-error assumed available connection
-      const signer = window.keepkey?.cosmos?.getOfflineSignerOnlyAmino(ChainIdToChain[chain]);
-      if (!signer) throw new SwapKitError("wallet_keepkey_signer_not_found");
-      const toolbox = getCosmosToolbox(chain, { signer });
-
-      const accounts = await signer.getAccounts();
-      if (!accounts?.[0]?.address) throw new SwapKitError("wallet_keepkey_no_accounts");
-
-      const [{ address }] = accounts;
-
-      return { ...toolbox, address };
-    }
-
-    case Chain.Dash:
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin: {
-      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-      const toolbox = await getUtxoToolbox(chain);
-
-      const getBalance = async () => {
-        const providerChain = getProviderNameFromChain(chain);
-        // @ts-expect-error We assuming there chains via switch
-        const balance = await window?.keepkey?.[providerChain]?.request({
-          method: "request_balance",
-        });
-        const assetValue = AssetValue.from({ chain, value: balance[0].balance });
-        return [assetValue];
-      };
-
-      return { ...toolbox, getBalance, transfer: walletTransfer };
-    }
-
-    case Chain.Ethereum:
-    case Chain.BinanceSmartChain:
-    case Chain.Base:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.Avalanche: {
-      const { prepareNetworkSwitch, switchEVMWalletNetwork } = await import("@swapkit/helpers");
-      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-      const { BrowserProvider } = await import("ethers");
-      const ethereumWindowProvider = getKEEPKEYProvider(chain) as Eip1193Provider;
-
-      if (!ethereumWindowProvider) {
-        throw new SwapKitError("wallet_keepkey_not_found");
-      }
-
-      const provider = new BrowserProvider(ethereumWindowProvider, "any");
-      const signer = await provider.getSigner();
-      const toolbox = await getEvmToolbox(chain, { provider, signer });
-      const keepkeyMethods = getKEEPKEYMethods(provider, chain);
-
-      try {
-        if (chain !== Chain.Ethereum) {
-          const networkParams = toolbox.getNetworkParams();
-          await switchEVMWalletNetwork(provider, chain, networkParams);
-        }
-      } catch (_error) {
-        throw new SwapKitError({
-          errorKey: "wallet_failed_to_add_or_switch_network",
-          info: { wallet: WalletOption.KEEPKEY, chain },
-        });
-      }
-
-      return prepareNetworkSwitch({
-        provider,
-        chain,
-        toolbox: { ...toolbox, ...keepkeyMethods },
-      });
-    }
-
-    default:
-      return null;
-  }
-}

package/src/keepkey-bex/walletHelpers.ts

@@ -1,255 +0,0 @@
-import {
-  type AssetValue,
-  Chain,
-  type EVMChain,
-  EVMChains,
-  type FeeOption,
-  SwapKitError,
-  WalletOption,
-} from "@swapkit/helpers";
-import { erc20ABI } from "@swapkit/helpers/contracts";
-import type { ApproveParams, CallParams, EVMTxParams } from "@swapkit/toolboxes/evm";
-import type { BrowserProvider, Eip1193Provider } from "ethers";
-
-interface UTXOProvider {
-  request: (
-    args: {
-      method: string;
-      params?: {
-        amount: { amount: string; decimals?: number };
-        asset: { chain: Chain; symbol: string; ticker: string };
-        memo: string | undefined;
-        from?: string;
-        recipient: string;
-        gasLimit?: string | bigint;
-      }[];
-    },
-    callback: (err: string, tx: string) => void,
-  ) => void;
-}
-
-type TransactionMethod = "transfer" | "deposit";
-
-type TransactionParams = {
-  asset: string | { chain: string; symbol: string; ticker: string };
-  amount: number | string | { amount: string | number; decimals?: number };
-  decimal?: number;
-  recipient: string;
-  memo?: string;
-};
-
-export type WalletTxParams = {
-  feeOptionKey?: FeeOption;
-  from?: string;
-  memo?: string;
-  recipient: string;
-  assetValue: AssetValue;
-  gasLimit?: string | bigint | undefined;
-};
-
-export const getProviderNameFromChain = (chain: Chain): string => {
-  switch (chain) {
-    case Chain.Bitcoin:
-      return "bitcoin";
-    case Chain.BitcoinCash:
-      return "bitcoincash";
-    case Chain.Dash:
-      return "dash";
-    case Chain.Dogecoin:
-      return "dogecoin";
-    case Chain.Litecoin:
-      return "litecoin";
-    default:
-      throw new SwapKitError("wallet_keepkey_chain_not_supported", { chain });
-  }
-};
-
-declare const window: {
-  keepkey?: {
-    binance: Eip1193Provider;
-    bitcoin: Eip1193Provider;
-    bitcoincash: Eip1193Provider;
-    dogecoin: Eip1193Provider;
-    ethereum: Eip1193Provider;
-    cosmos: Eip1193Provider;
-    dash: Eip1193Provider;
-    litecoin: Eip1193Provider;
-    thorchain: Eip1193Provider;
-    mayachain: Eip1193Provider;
-  };
-} & Window;
-
-export function getKEEPKEYProvider<T extends Chain>(chain: T) {
-  if (!window.keepkey) throw new SwapKitError("wallet_keepkey_not_found");
-
-  switch (chain) {
-    case Chain.Ethereum:
-    case Chain.Base:
-    case Chain.Avalanche:
-    case Chain.BinanceSmartChain:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-      return window.keepkey.ethereum as Eip1193Provider;
-    case Chain.Cosmos:
-      return window.keepkey.cosmos as Eip1193Provider;
-    case Chain.Bitcoin:
-      return window.keepkey.bitcoin as UTXOProvider;
-    case Chain.BitcoinCash:
-      return window.keepkey.bitcoincash as UTXOProvider;
-    case Chain.Dogecoin:
-      return window.keepkey.dogecoin as UTXOProvider;
-    case Chain.Litecoin:
-      return window.keepkey.litecoin as UTXOProvider;
-    case Chain.Dash:
-      return window.keepkey.dash as UTXOProvider;
-    case Chain.THORChain:
-      return window.keepkey.thorchain as UTXOProvider;
-    case Chain.Maya:
-      return window.keepkey.mayachain as UTXOProvider;
-
-    default:
-      return undefined;
-  }
-}
-
-async function transaction({
-  method,
-  params,
-  chain,
-}: {
-  method: TransactionMethod;
-  params: TransactionParams[];
-  chain: Chain;
-}): Promise<string> {
-  const client = getKEEPKEYProvider(chain);
-
-  return new Promise<string>((resolve, reject) => {
-    if (client && "request" in client) {
-      // @ts-ignore
-      client.request({ method, params }, (err: string, tx: string) => {
-        err ? reject(err) : resolve(tx);
-      });
-    } else {
-      reject(new SwapKitError("wallet_provider_not_found"));
-    }
-  });
-}
-
-export async function getKEEPKEYAddress(chain: Chain) {
-  const eipProvider = getKEEPKEYProvider(chain) as Eip1193Provider;
-  if (!eipProvider) {
-    throw new SwapKitError({
-      errorKey: "wallet_provider_not_found",
-      info: { wallet: WalletOption.KEEPKEY, chain },
-    });
-  }
-
-  let method = "request_accounts";
-  if (EVMChains.includes(chain as EVMChain)) {
-    method = "eth_requestAccounts";
-  }
-
-  const [response] = await eipProvider.request({ method, params: [] });
-  return response;
-}
-
-export async function walletTransfer(
-  { assetValue, recipient, memo, gasLimit }: WalletTxParams & { assetValue: AssetValue },
-  method: TransactionMethod = "transfer",
-) {
-  if (!assetValue) {
-    throw new SwapKitError("wallet_keepkey_asset_not_defined");
-  }
-
-  const from = await getKEEPKEYAddress(assetValue.chain);
-  const params = [
-    {
-      amount: {
-        amount: assetValue.getValue("string"),
-        decimals: assetValue.decimal,
-      },
-      asset: {
-        chain: assetValue.chain,
-        symbol: assetValue.symbol.toUpperCase(),
-        ticker: assetValue.symbol.toUpperCase(),
-      },
-      memo,
-      from,
-      recipient,
-      gasLimit,
-    },
-  ];
-
-  return transaction({ method, params, chain: assetValue.chain });
-}
-
-export function getKEEPKEYMethods(provider: BrowserProvider, chain: EVMChain) {
-  return {
-    call: async <T>({
-      contractAddress,
-      abi,
-      funcName,
-      funcParams = [],
-      txOverrides,
-    }: CallParams): Promise<T> => {
-      if (!contractAddress) {
-        throw new SwapKitError("wallet_keepkey_contract_address_not_provided");
-      }
-      const { createContract, getCreateContractTxObject, isStateChangingCall, toHexString } =
-        await import("@swapkit/toolboxes/evm");
-
-      const isStateChanging = isStateChangingCall({ abi, funcName });
-
-      if (isStateChanging) {
-        const createTx = getCreateContractTxObject({ provider, chain });
-        const { value, from, to, data } = await createTx({
-          contractAddress,
-          abi,
-          funcName,
-          funcParams,
-          txOverrides,
-        });
-
-        return provider.send("eth_sendTransaction", [
-          { value: toHexString(BigInt(value || 0)), from, to, data: data || "0x" },
-        ]);
-      }
-      const contract = createContract(contractAddress, abi, provider);
-
-      const result = await contract[funcName]?.(...funcParams);
-
-      return typeof result?.hash === "string" ? result?.hash : result;
-    },
-    approve: async ({ assetAddress, spenderAddress, amount, from }: ApproveParams) => {
-      const { MAX_APPROVAL, getCreateContractTxObject, toHexString } = await import(
-        "@swapkit/toolboxes/evm"
-      );
-
-      const createTx = getCreateContractTxObject({ provider, chain });
-      const { value, to, data } = await createTx({
-        contractAddress: assetAddress,
-        abi: erc20ABI,
-        funcName: "approve",
-        funcParams: [spenderAddress, BigInt(amount || MAX_APPROVAL)],
-        txOverrides: { from },
-      });
-
-      return provider.send("eth_sendTransaction", [
-        { value: toHexString(BigInt(value || 0)), from, to, data: data || "0x" },
-      ]);
-    },
-    sendTransaction: async (tx: EVMTxParams) => {
-      const { from, to, data, value } = tx;
-      if (!to) {
-        throw new SwapKitError("wallet_keepkey_send_transaction_no_address");
-      }
-
-      const { toHexString } = await import("@swapkit/toolboxes/evm");
-
-      return provider.send("eth_sendTransaction", [
-        { value: toHexString(BigInt(value || 0)), from, to, data: data || "0x" },
-      ]);
-    },
-  };
-}