@swapkit/wallets 3.0.0-beta.2 → 3.0.0-beta.21

package/src/coinbase/signer.ts

@@ -1,6 +1,6 @@
 import type { CoinbaseWalletProvider } from "@coinbase/wallet-sdk";
 import type { createCoinbaseWalletSDK } from "@coinbase/wallet-sdk/dist/createCoinbaseWalletSDK.js";
-import { Chain } from "@swapkit/helpers";
+import { Chain, SwapKitError } from "@swapkit/helpers";
 import type { Provider } from "ethers";
 
 async function getCoinbaseMobileSigner(
@@ -22,7 +22,7 @@ async function getCoinbaseMobileSigner(
         method: "eth_requestAccounts",
       });
 
-      if (!accounts[0]) throw new Error("No Account found");
+      if (!accounts[0]) throw new SwapKitError("wallet_coinbase_no_accounts");
 
       return accounts[0];
     }
@@ -41,7 +41,7 @@ async function getCoinbaseMobileSigner(
     }
 
     signTypedData = () => {
-      throw new Error("this method is not implemented");
+      throw new SwapKitError("wallet_coinbase_method_not_supported", { method: "signTypedData" });
     };
 
     connect(provider: Provider) {
@@ -78,6 +78,6 @@ export const getWalletMethods = async ({
     }
 
     default:
-      throw new Error(`No wallet for chain ${chain}`);
+      throw new SwapKitError("wallet_coinbase_chain_not_supported", { chain });
   }
 };

package/src/cosmostation/index.ts

@@ -0,0 +1,142 @@
+import type { Keplr } from "@keplr-wallet/types";
+import {
+  Chain,
+  ChainId,
+  ChainToChainId,
+  SwapKitError,
+  WalletOption,
+  createWallet,
+  filterSupportedChains,
+} from "@swapkit/helpers";
+
+const cosmostationSupportedChainIds = [ChainId.Cosmos, ChainId.Kujira, ChainId.THORChain] as const;
+const cosmostationSupportedEVMChains = [
+  Chain.Ethereum,
+  Chain.BinanceSmartChain,
+  Chain.Avalanche,
+  Chain.Polygon,
+  Chain.Arbitrum,
+  Chain.Optimism,
+  Chain.Base,
+] as const;
+
+declare global {
+  interface Window {
+    cosmostation?: {
+      providers?: {
+        keplr?: Keplr;
+      };
+    };
+  }
+}
+
+async function connectCosmosChains(chains: Chain[], addChain: any, keplrProvider: Keplr) {
+  await Promise.all(
+    chains.map(async (chain) => {
+      const chainId = ChainToChainId[chain] as (typeof cosmostationSupportedChainIds)[number];
+
+      await keplrProvider.enable(chainId);
+      const signer = keplrProvider.getOfflineSignerOnlyAmino(chainId);
+      if (!signer) throw new SwapKitError("wallet_cosmostation_signer_not_found");
+
+      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
+
+      const accounts = await signer.getAccounts();
+      if (!accounts?.[0]?.address) throw new SwapKitError("wallet_cosmostation_no_accounts");
+
+      const [{ address }] = accounts;
+      const toolbox = getCosmosToolbox(chain as any, { signer });
+
+      addChain({
+        ...toolbox,
+        chain,
+        address,
+        walletType: WalletOption.COSMOSTATION,
+      });
+    }),
+  );
+}
+
+async function connectEvmChains(chains: Chain[], addChain: any) {
+  const provider = window.ethereum;
+
+  if (!provider) {
+    throw new SwapKitError("wallet_cosmostation_evm_provider_not_found");
+  }
+
+  const accounts = (await provider.request({
+    method: "eth_requestAccounts",
+  })) as string[];
+
+  if (!accounts || accounts.length === 0) {
+    throw new SwapKitError("wallet_cosmostation_no_evm_accounts");
+  }
+
+  const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
+
+  for (const chain of chains) {
+    const toolbox = getEvmToolbox(chain as any, { provider });
+    const [address] = accounts;
+
+    if (!address) {
+      throw new SwapKitError("wallet_cosmostation_no_evm_address");
+    }
+
+    addChain({
+      ...toolbox,
+      chain,
+      address,
+      walletType: WalletOption.COSMOSTATION,
+    });
+  }
+}
+
+export const cosmostationWallet = createWallet({
+  name: "connectCosmostation",
+  supportedChains: [
+    Chain.Cosmos,
+    Chain.Kujira,
+    Chain.THORChain,
+    Chain.Ethereum,
+    Chain.BinanceSmartChain,
+    Chain.Avalanche,
+    Chain.Polygon,
+    Chain.Arbitrum,
+    Chain.Optimism,
+    Chain.Base,
+  ],
+  connect: ({ addChain, supportedChains }) =>
+    async function connectCosmostation(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({
+        chains,
+        supportedChains,
+        walletType: WalletOption.COSMOSTATION,
+      });
+
+      if (!window.cosmostation) {
+        throw new SwapKitError("wallet_cosmostation_not_found");
+      }
+
+      const cosmosChains = filteredChains.filter((chain) =>
+        cosmostationSupportedChainIds.includes(ChainToChainId[chain] as any),
+      );
+      const evmChains = filteredChains.filter((chain) =>
+        cosmostationSupportedEVMChains.includes(chain as any),
+      );
+
+      if (cosmosChains.length > 0) {
+        const keplrProvider = window.cosmostation.providers?.keplr;
+        if (!keplrProvider) {
+          throw new SwapKitError("wallet_cosmostation_keplr_provider_not_found");
+        }
+
+        await connectCosmosChains(cosmosChains, addChain, keplrProvider);
+      }
+
+      if (evmChains.length > 0) {
+        await connectEvmChains(evmChains, addChain);
+      }
+
+      return true;
+    },
+});

package/src/ctrl/walletHelpers.ts

@@ -8,6 +8,7 @@ import {
   type FeeOption,
   SwapKitError,
   WalletOption,
+  providerRequest,
 } from "@swapkit/helpers";
 import { erc20ABI } from "@swapkit/helpers/contracts";
 import type { ApproveParams, CallParams, EVMTxParams } from "@swapkit/toolboxes/evm";
@@ -59,12 +60,14 @@ export async function getCtrlProvider<T extends Chain>(
       Chain.Polygon,
       () => window.xfi?.ethereum,
     )
-    .with(Chain.Cosmos, Chain.Kujira, Chain.Maya, Chain.THORChain, () => window.xfi?.keplr)
+    .with(Chain.Cosmos, Chain.Kujira, () => window.xfi?.keplr)
     .with(Chain.Bitcoin, () => window.xfi?.bitcoin)
     .with(Chain.BitcoinCash, () => window.xfi?.bitcoincash)
     .with(Chain.Dogecoin, () => window.xfi?.dogecoin)
     .with(Chain.Litecoin, () => window.xfi?.litecoin)
     .with(Chain.Solana, () => window.xfi?.solana)
+    .with(Chain.THORChain, () => window.xfi?.thorchain)
+    .with(Chain.Maya, () => window.xfi?.mayachain)
     .otherwise(() => undefined);
 }
 
@@ -90,55 +93,67 @@ async function transaction({
 }
 
 export async function getCtrlAddress(chain: Chain) {
-  const eipProvider = (await getCtrlProvider(chain)) as Eip1193Provider;
-  if (!eipProvider) {
-    throw new SwapKitError({
-      errorKey: "wallet_provider_not_found",
-      info: { wallet: WalletOption.CTRL, chain },
-    });
-  }
-
-  if ([Chain.Cosmos, Chain.Kujira].includes(chain)) {
-    const provider = await getCtrlProvider(Chain.Cosmos);
-    if (!provider || "request" in provider) {
+  try {
+    const eipProvider = (await getCtrlProvider(chain)) as Eip1193Provider;
+    if (!eipProvider) {
       throw new SwapKitError({
         errorKey: "wallet_provider_not_found",
         info: { wallet: WalletOption.CTRL, chain },
       });
     }
 
-    // Enabling before using the Keplr is recommended.
-    // This method will ask the user whether to allow access if they haven't visited this website.
-    // Also, it will request that the user unlock the wallet if the wallet is locked.
-    const chainId = ChainToChainId[chain];
-    await provider.enable(chainId);
+    if ([Chain.Cosmos, Chain.Kujira].includes(chain)) {
+      const provider = await getCtrlProvider(Chain.Cosmos);
+      if (!provider || "request" in provider) {
+        throw new SwapKitError({
+          errorKey: "wallet_provider_not_found",
+          info: { wallet: WalletOption.CTRL, chain },
+        });
+      }
 
-    const offlineSigner = provider.getOfflineSigner(chainId);
+      // Enabling before using the Keplr is recommended.
+      // This method will ask the user whether to allow access if they haven't visited this website.
+      // Also, it will request that the user unlock the wallet if the wallet is locked.
+      const chainId = ChainToChainId[chain];
+      await provider.enable(chainId);
 
-    const [item] = await offlineSigner.getAccounts();
-    return item?.address;
-  }
+      const offlineSigner = provider.getOfflineSigner(chainId);
 
-  if (EVMChains.includes(chain as EVMChain)) {
-    const [response] = await eipProvider.request({ method: "eth_requestAccounts", params: [] });
+      const [item] = await offlineSigner.getAccounts();
+      return item?.address;
+    }
 
-    return response;
-  }
+    if (EVMChains.includes(chain as EVMChain)) {
+      // For CTRL wallet, we need to use the request method directly on the provider
+      if ("request" in eipProvider && typeof eipProvider.request === "function") {
+        const accounts = await eipProvider.request({ method: "eth_requestAccounts" });
+        return accounts[0];
+      }
+      const { BrowserProvider } = await import("ethers");
+      const provider = new BrowserProvider(eipProvider, "any");
+      const [response] = await providerRequest({
+        provider,
+        method: "eth_requestAccounts",
+        params: [],
+      });
+      return response;
+    }
 
-  if (chain === Chain.Solana) {
-    const provider = await getCtrlProvider(Chain.Solana);
+    if (chain === Chain.Solana) {
+      const provider = await getCtrlProvider(Chain.Solana);
 
-    const accounts = await provider.connect();
-    return accounts.publicKey.toString();
-  }
+      const accounts = await provider.connect();
+      return accounts.publicKey.toString();
+    }
 
-  return new Promise((resolve, reject) =>
-    eipProvider.request(
-      { method: "request_accounts", params: [] },
-      // @ts-expect-error
-      (error: any, [response]: string[]) => (error ? reject(error) : resolve(response)),
-    ),
-  );
+    const accounts = await eipProvider.request({ method: "request_accounts", params: [] });
+    return accounts[0];
+  } catch (_error) {
+    throw new SwapKitError({
+      errorKey: "wallet_provider_not_found",
+      info: { wallet: WalletOption.CTRL, chain },
+    });
+  }
 }
 
 export async function walletTransfer(
@@ -188,8 +203,9 @@ export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
       if (!contractAddress) {
         throw new SwapKitError("wallet_ctrl_contract_address_not_provided");
       }
-      const { createContract, getCreateContractTxObject, isStateChangingCall, toHexString } =
-        await import("@swapkit/toolboxes/evm");
+      const { createContract, getCreateContractTxObject, isStateChangingCall } = await import(
+        "@swapkit/toolboxes/evm"
+      );
 
       const isStateChanging = isStateChangingCall({ abi, funcName });
 
@@ -203,14 +219,14 @@ export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
           txOverrides,
         });
 
-        return provider.send("eth_sendTransaction", [
-          {
-            value: toHexString(BigInt(value || 0)),
-            from,
-            to,
-            data: data || "0x",
-          } as any,
-        ]);
+        const signer = await provider.getSigner();
+        const tx = await signer.sendTransaction({
+          value: BigInt(value || 0),
+          from,
+          to,
+          data: data || "0x",
+        });
+        return tx.hash as T;
       }
       const contract = createContract(contractAddress, abi, provider);
 
@@ -219,9 +235,7 @@ export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
       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 { MAX_APPROVAL, getCreateContractTxObject } = await import("@swapkit/toolboxes/evm");
       const funcParams = [spenderAddress, BigInt(amount || MAX_APPROVAL)];
       const txOverrides = { from };
 
@@ -236,31 +250,29 @@ export function getCtrlMethods(provider: BrowserProvider, chain: EVMChain) {
       const createTx = getCreateContractTxObject({ provider, chain });
       const { value, to, data } = await createTx(functionCallParams);
 
-      return provider.send("eth_sendTransaction", [
-        {
-          value: toHexString(BigInt(value || 0)),
-          from,
-          to,
-          data: data || "0x",
-        } as any,
-      ]);
+      const signer = await provider.getSigner();
+      const tx = await signer.sendTransaction({
+        value: BigInt(value || 0),
+        from,
+        to,
+        data: data || "0x",
+      });
+      return tx.hash;
     },
-    sendTransaction: async (tx: EVMTxParams) => {
-      const { from, to, data, value } = tx;
+    sendTransaction: async (txParams: EVMTxParams) => {
+      const { from, to, data, value } = txParams;
       if (!to) {
         throw new SwapKitError("wallet_ctrl_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",
-        } as any,
-      ]);
+      const signer = await provider.getSigner();
+      const tx = await signer.sendTransaction({
+        value: BigInt(value || 0),
+        from,
+        to,
+        data: data || "0x",
+      });
+      return tx.hash;
     },
   };
 }

package/src/evm-extensions/index.ts

@@ -3,6 +3,7 @@ import {
   ChainToHexChainId,
   type EVMChain,
   EVMChains,
+  SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
@@ -49,7 +50,7 @@ export const getWeb3WalletMethods = async ({
   chain: EVMChain;
   provider: BrowserProvider;
 }) => {
-  if (!walletProvider) throw new Error("Requested web3 wallet is not installed");
+  if (!walletProvider) throw new SwapKitError("wallet_evm_extensions_not_found");
   const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
 
   const signer = await provider.getSigner();
@@ -62,7 +63,7 @@ export const getWeb3WalletMethods = async ({
         const networkParams = toolbox.getNetworkParams();
         await switchEVMWalletNetwork(provider, chain, networkParams);
       } catch (_error) {
-        throw new Error(`Failed to add/switch ${chain} network: ${chain}`);
+        throw new SwapKitError("wallet_evm_extensions_failed_to_switch_network", { chain });
       }
     }
   }
@@ -89,7 +90,7 @@ export const evmWallet = createWallet({
       await Promise.all(
         filteredChains.map(async (chain) => {
           if (walletType === WalletOption.EIP6963) {
-            if (!eip1193Provider) throw new Error("Missing provider");
+            if (!eip1193Provider) throw new SwapKitError("wallet_evm_extensions_no_provider");
 
             const provider = new BrowserProvider(eip1193Provider, "any");
             await provider.send("eth_requestAccounts", []);

package/src/exodus/index.ts

@@ -9,7 +9,7 @@ import {
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
-import type { Psbt } from "bitcoinjs-lib";
+import { Psbt } from "bitcoinjs-lib";
 import type { BrowserProvider, Eip1193Provider } from "ethers";
 import {
   AddressPurpose,
@@ -34,7 +34,6 @@ async function getWalletMethods({
 }) {
   switch (chain) {
     case Chain.Bitcoin: {
-      const { Psbt } = await import("bitcoinjs-lib");
       const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
 
       let address = "";
@@ -50,11 +49,11 @@ async function getWalletMethods({
           network: { type: BitcoinNetworkType.Mainnet },
         },
         onFinish: (response: GetAddressResponse) => {
-          if (!response.addresses[0]) throw new Error("No address found");
+          if (!response.addresses[0]) throw new SwapKitError("wallet_exodus_no_address");
           address = response.addresses[0].address;
         },
         onCancel: () => {
-          throw new Error("Request canceled");
+          throw new SwapKitError("wallet_exodus_request_canceled");
         },
       };
 
@@ -80,7 +79,7 @@ async function getWalletMethods({
             signedPsbt = Psbt.fromBase64(response.psbtBase64);
           },
           onCancel: () => {
-            throw new Error("Signature canceled");
+            throw new SwapKitError("wallet_exodus_signature_canceled");
           },
         };
 
@@ -104,7 +103,7 @@ async function getWalletMethods({
     case Chain.Ethereum:
     case Chain.Optimism:
     case Chain.Polygon: {
-      if (!walletProvider) throw new Error("Requested web3 wallet is not installed");
+      if (!walletProvider) throw new SwapKitError("wallet_exodus_not_found");
       const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
 
       const jsonRpcProvider = await getProvider(chain);
@@ -122,13 +121,13 @@ async function getWalletMethods({
           await switchEVMWalletNetwork(browserProvider, chain, networkParams);
         }
       } catch (_error) {
-        throw new Error(`Failed to add/switch ${chain} network: ${chain}`);
+        throw new SwapKitError("wallet_exodus_failed_to_switch_network", { chain });
       }
 
       return { ...prepareNetworkSwitch({ toolbox, chain, provider: browserProvider }), address };
     }
     default:
-      throw new Error(`Unsupported chain: ${chain}`);
+      throw new SwapKitError("wallet_exodus_chain_not_supported", { chain });
   }
 }
 
@@ -138,7 +137,7 @@ export const exodusWallet = createWallet({
   supportedChains: [...EVMChains, Chain.Bitcoin],
   connect: ({ addChain, walletType, supportedChains }) =>
     async function connectExodusWallet(chains: Chain[], wallet: Wallet) {
-      if (!wallet) throw new Error("Missing Exodus Wallet instance");
+      if (!wallet) throw new SwapKitError("wallet_exodus_instance_missing");
       const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
       const { BrowserProvider } = await import("ethers");
 

package/src/keepkey/chains/cosmos.ts

@@ -21,64 +21,58 @@ export const cosmosWalletMethods = async ({
     getFeeRateFromThorswap,
     createStargateClient,
   } = await import("@swapkit/toolboxes/cosmos");
+  const derivationPathString = derivationPath
+    ? derivationPathToString(derivationPath)
+    : `${DerivationPath.GAIA}/0`;
 
-  try {
-    const derivationPathString = derivationPath
-      ? derivationPathToString(derivationPath)
-      : `${DerivationPath.GAIA}/0`;
+  const { address: fromAddress } = (await sdk.address.cosmosGetAddress({
+    address_n: bip32ToAddressNList(derivationPathString),
+  })) as { address: string };
 
-    const { address: fromAddress } = (await sdk.address.cosmosGetAddress({
-      address_n: bip32ToAddressNList(derivationPathString),
-    })) as { address: string };
+  const toolbox = await getCosmosToolbox(Chain.Cosmos);
 
-    const toolbox = await getCosmosToolbox(Chain.Cosmos);
-
-    if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
-      DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
-        await getFeeRateFromThorswap(ChainId.Cosmos, 500),
-      );
-    }
+  if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
+    DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
+      await getFeeRateFromThorswap(ChainId.Cosmos, 500),
+    );
+  }
 
-    // TODO support other cosmos assets
-    const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-      const amount = assetValue.getBaseValue("string");
-      const accountInfo = await toolbox.getAccount(fromAddress);
+  // TODO support other cosmos assets
+  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
+    const amount = assetValue.getBaseValue("string");
+    const accountInfo = await toolbox.getAccount(fromAddress);
 
-      const keepKeySignedTx = await sdk.cosmos.cosmosSignAmino({
-        signerAddress: fromAddress,
-        signDoc: {
-          fee: DEFAULT_COSMOS_FEE_MAINNET,
-          memo: memo || "",
-          sequence: accountInfo?.sequence.toString() ?? "",
-          chain_id: ChainId.Cosmos,
-          account_number: accountInfo?.accountNumber.toString() ?? "",
-          msgs: [
-            {
-              value: {
-                amount: [{ denom: "uatom", amount }],
-                to_address: recipient,
-                from_address: fromAddress,
-              },
-              type: "cosmos-sdk/MsgSend",
+    const keepKeySignedTx = await sdk.cosmos.cosmosSignAmino({
+      signerAddress: fromAddress,
+      signDoc: {
+        fee: DEFAULT_COSMOS_FEE_MAINNET,
+        memo: memo || "",
+        sequence: accountInfo?.sequence.toString() ?? "",
+        chain_id: ChainId.Cosmos,
+        account_number: accountInfo?.accountNumber.toString() ?? "",
+        msgs: [
+          {
+            value: {
+              amount: [{ denom: "uatom", amount }],
+              to_address: recipient,
+              from_address: fromAddress,
             },
-          ],
-        },
-      });
+            type: "cosmos-sdk/MsgSend",
+          },
+        ],
+      },
+    });
 
-      const decodedBytes = atob(keepKeySignedTx.serialized);
-      const uint8Array = new Uint8Array(decodedBytes.length).map((_, i) =>
-        decodedBytes.charCodeAt(i),
-      );
+    const decodedBytes = atob(keepKeySignedTx.serialized);
+    const uint8Array = new Uint8Array(decodedBytes.length).map((_, i) =>
+      decodedBytes.charCodeAt(i),
+    );
 
-      const client = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Cosmos]);
-      const response = await client.broadcastTx(uint8Array);
+    const client = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Cosmos]);
+    const response = await client.broadcastTx(uint8Array);
 
-      return response.transactionHash;
-    };
+    return response.transactionHash;
+  };
 
-    return { ...toolbox, transfer, address: fromAddress };
-  } catch (e) {
-    console.error(e);
-    throw e;
-  }
+  return { ...toolbox, transfer, address: fromAddress };
 };

package/src/keepkey/chains/evm.ts

@@ -4,6 +4,7 @@ import {
   ChainToChainId,
   type DerivationPathArray,
   NetworkDerivationPath,
+  SwapKitError,
   derivationPathToString,
 } from "@swapkit/helpers";
 import type { JsonRpcProvider, Provider, TransactionRequest } from "ethers";
@@ -35,7 +36,7 @@ export class KeepKeySigner extends AbstractSigner {
   }
 
   signTypedData(): Promise<string> {
-    throw new Error("this method is not implemented");
+    throw new SwapKitError("wallet_keepkey_method_not_supported", { method: "signTypedData" });
   }
 
   getAddress = async () => {
@@ -62,14 +63,21 @@ export class KeepKeySigner extends AbstractSigner {
     gasPrice,
     // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
   }: TransactionRequest) => {
-    if (!to) throw new Error("Missing to address");
-    if (!gasLimit) throw new Error("Missing gasLimit");
-    if (!data) throw new Error("Missing data");
+    if (!to)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing to address" });
+    if (!gasLimit)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasLimit" });
+    if (!data) throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing data" });
 
     const isEIP1559 = !!((maxFeePerGas || maxPriorityFeePerGas) && !gasPrice);
-    if (isEIP1559 && !maxFeePerGas) throw new Error("Missing maxFeePerGas");
-    if (isEIP1559 && !maxPriorityFeePerGas) throw new Error("Missing maxFeePerGas");
-    if (!(isEIP1559 || gasPrice)) throw new Error("Missing gasPrice");
+    if (isEIP1559 && !maxFeePerGas)
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing maxFeePerGas" });
+    if (isEIP1559 && !maxPriorityFeePerGas)
+      throw new SwapKitError("wallet_keepkey_invalid_params", {
+        reason: "Missing maxPriorityFeePerGas",
+      });
+    if (!(isEIP1559 || gasPrice))
+      throw new SwapKitError("wallet_keepkey_invalid_params", { reason: "Missing gasPrice" });
 
     const { toHexString } = await import("@swapkit/toolboxes/evm");
 
@@ -100,7 +108,7 @@ export class KeepKeySigner extends AbstractSigner {
   };
 
   sendTransaction = async (tx: TransactionRequest): Promise<any> => {
-    if (!this.provider) throw new Error("No provider set");
+    if (!this.provider) throw new SwapKitError("wallet_keepkey_no_provider");
 
     const signedTxHex = await this.signTransaction(tx);