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

package/src/ledger/clients/xrp.ts

@@ -0,0 +1,66 @@
+import type Xrp from "@ledgerhq/hw-app-xrp";
+import type Transport from "@ledgerhq/hw-transport";
+import {
+  Chain,
+  type DerivationPathArray,
+  NetworkDerivationPath,
+  derivationPathToString,
+} from "@swapkit/helpers";
+import type { Transaction } from "@swapkit/toolboxes/ripple";
+import { encode } from "ripple-binary-codec";
+import type { Payment } from "xrpl";
+import { getLedgerTransport } from "../helpers";
+
+const TF_FULLY_CANONICAL_SIG = 2147483648;
+
+function cleanTransactionObject(obj: Record<string, any>) {
+  const cleaned: Record<string, any> = {};
+  for (const key in obj) {
+    if (obj[key] !== null && obj[key] !== undefined) {
+      cleaned[key] = obj[key];
+    }
+  }
+  return cleaned;
+}
+
+async function establishConnection(transport: Transport) {
+  const { default: Xrp } = await import("@ledgerhq/hw-app-xrp");
+  return new Xrp(transport);
+}
+
+function fetchAddressAndPublicKey({
+  instance,
+  derivationPath,
+}: { instance: Xrp; derivationPath: string }) {
+  return instance.getAddress(derivationPath);
+}
+
+export const XRPLedger = async (derivationPath?: DerivationPathArray) => {
+  const path = derivationPathToString(derivationPath || NetworkDerivationPath[Chain.Ripple]);
+  const transport = await getLedgerTransport();
+  const xrpInstance = await establishConnection(transport);
+
+  const { address, publicKey } = await fetchAddressAndPublicKey({
+    instance: xrpInstance,
+    derivationPath: path,
+  });
+
+  async function sign(transaction: Payment | Transaction) {
+    const { hashes } = await import("@swapkit/toolboxes/ripple");
+    const cleanedTxWithPubKey = cleanTransactionObject(transaction);
+    const transactionJSON = {
+      ...cleanedTxWithPubKey,
+      Flags: transaction.Flags || TF_FULLY_CANONICAL_SIG,
+      SigningPubKey: publicKey.toUpperCase(),
+    };
+
+    const transactionToSignOnLedger = encode(transactionJSON);
+    const txnSignature = await xrpInstance.signTransaction(path, transactionToSignOnLedger);
+    const tx_blob = encode({ ...transactionJSON, TxnSignature: txnSignature });
+    const hash = hashes.hashSignedTx(tx_blob);
+
+    return { tx_blob, hash };
+  }
+
+  return { address, sign };
+};

package/src/ledger/cosmosTypes.ts

@@ -1,3 +1,5 @@
+import { SwapKitError } from "@swapkit/helpers";
+
 export interface Coin {
   readonly denom: string;
   readonly amount: string;
@@ -57,12 +59,14 @@ export class AminoTypes {
   toAmino({ typeUrl, value }: EncodeObject): AminoMsg {
     const converter = this.register[typeUrl];
     if (converter === "not_supported_by_chain") {
-      throw new Error(
-        `The message type '${typeUrl}' cannot be signed using the Amino JSON sign mode because this is not supported by chain.`,
-      );
+      throw new SwapKitError("wallet_ledger_chain_not_supported", {
+        reason: `The message type '${typeUrl}' cannot be signed using the Amino JSON sign mode because this is not supported by chain.`,
+      });
     }
     if (!converter) {
-      throw new Error(`Type URL '${typeUrl}' does not exist in the Amino message type register. `);
+      throw new SwapKitError("wallet_ledger_invalid_params", {
+        reason: `Type URL '${typeUrl}' does not exist in the Amino message type register.`,
+      });
     }
     return {
       type: converter.aminoType,
@@ -76,18 +80,18 @@ export class AminoTypes {
       .filter(([_typeUrl, { aminoType }]) => aminoType === type);
 
     if (matches.length === 0) {
-      throw new Error(
-        `Amino type identifier '${type}' does not exist in the Amino message type register.`,
-      );
+      throw new SwapKitError("wallet_ledger_invalid_params", {
+        reason: `Amino type identifier '${type}' does not exist in the Amino message type register.`,
+      });
     }
 
     if (matches.length > 1) {
-      throw new Error(
-        `Multiple types are registered with Amino type identifier '${type}': '${matches
+      throw new SwapKitError("wallet_ledger_invalid_params", {
+        reason: `Multiple types are registered with Amino type identifier '${type}': '${matches
           .map(([key, _value]) => key)
           .sort()
           .join("', '")}'. Thus fromAmino cannot be performed.`,
-      );
+      });
     }
 
     const [typeUrl, converter] = matches[0] as [string, AminoConverter];

package/src/ledger/helpers/getLedgerAddress.ts

@@ -1,15 +1,19 @@
 import { Chain, SwapKitError, WalletOption } from "@swapkit/helpers";
 
+import type { XRPLedger } from "../clients/xrp";
 import type { LEDGER_SUPPORTED_CHAINS } from "../index";
 import type { CosmosLedgerClients, EVMLedgerClients, UTXOLedgerClients } from "../types";
 import type { getLedgerClient } from "./getLedgerClient";
 
-export const getLedgerAddress = async ({
+export const getLedgerAddress = async <
+  T extends (typeof LEDGER_SUPPORTED_CHAINS)[number],
+  L extends Awaited<ReturnType<typeof getLedgerClient<T>>>,
+>({
   chain,
   ledgerClient,
 }: {
-  chain: (typeof LEDGER_SUPPORTED_CHAINS)[number];
-  ledgerClient: Awaited<ReturnType<typeof getLedgerClient>>;
+  chain: T;
+  ledgerClient: L;
 }) => {
   if (!ledgerClient) return "";
 
@@ -40,6 +44,11 @@ export const getLedgerAddress = async ({
 
       return chain === Chain.BitcoinCash ? address.replace("bitcoincash:", "") : address;
     }
+
+    case Chain.Ripple: {
+      return (ledgerClient as Awaited<ReturnType<typeof XRPLedger>>).address;
+    }
+
     default:
       throw new SwapKitError("wallet_chain_not_supported", { wallet: WalletOption.LEDGER, chain });
   }

package/src/ledger/helpers/getLedgerClient.ts

@@ -1,4 +1,10 @@
-import { Chain, type DerivationPathArray, SwapKitError, WalletOption } from "@swapkit/helpers";
+import {
+  Chain,
+  type DerivationPathArray,
+  type EVMChain,
+  SwapKitError,
+  WalletOption,
+} from "@swapkit/helpers";
 
 import { CosmosLedger } from "../clients/cosmos";
 import {
@@ -18,6 +24,7 @@ import {
   DogecoinLedger,
   LitecoinLedger,
 } from "../clients/utxo";
+import { XRPLedger } from "../clients/xrp";
 
 type LedgerSignerMap = {
   [Chain.Arbitrum]: ReturnType<typeof ArbitrumLedger>;
@@ -33,6 +40,7 @@ type LedgerSignerMap = {
   [Chain.Litecoin]: ReturnType<typeof LitecoinLedger>;
   [Chain.Optimism]: ReturnType<typeof OptimismLedger>;
   [Chain.Polygon]: ReturnType<typeof PolygonLedger>;
+  [Chain.Ripple]: ReturnType<typeof XRPLedger>;
   [Chain.THORChain]: THORChainLedger;
 };
 
@@ -45,51 +53,54 @@ export const getLedgerClient = async <T extends LedgerSupportedChain>({
   chain: T;
   derivationPath?: DerivationPathArray;
 }): Promise<LedgerSignerMap[T]> => {
-  switch (chain) {
-    case Chain.THORChain:
-      return new THORChainLedger(derivationPath) as LedgerSignerMap[T];
-    case Chain.Cosmos:
-      return new CosmosLedger(derivationPath) as LedgerSignerMap[T];
-    case Chain.Bitcoin:
-      return BitcoinLedger(derivationPath) as LedgerSignerMap[T];
-    case Chain.BitcoinCash:
-      return BitcoinCashLedger(derivationPath) as LedgerSignerMap[T];
-    case Chain.Dash:
-      return DashLedger(derivationPath) as LedgerSignerMap[T];
-    case Chain.Dogecoin:
-      return DogecoinLedger(derivationPath) as LedgerSignerMap[T];
-    case Chain.Litecoin:
-      return LitecoinLedger(derivationPath) as LedgerSignerMap[T];
-
-    case Chain.Arbitrum:
-    case Chain.Avalanche:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.Base: {
-      const { getProvider } = await import("@swapkit/toolboxes/evm");
-      const params = { provider: await getProvider(chain), derivationPath };
+  const { match } = await import("ts-pattern");
 
-      switch (chain) {
-        case Chain.BinanceSmartChain:
-          return BinanceSmartChainLedger(params) as LedgerSignerMap[T];
-        case Chain.Avalanche:
-          return AvalancheLedger(params) as LedgerSignerMap[T];
-        case Chain.Arbitrum:
-          return ArbitrumLedger(params) as LedgerSignerMap[T];
-        case Chain.Optimism:
-          return OptimismLedger(params) as LedgerSignerMap[T];
-        case Chain.Polygon:
-          return PolygonLedger(params) as LedgerSignerMap[T];
-        case Chain.Base:
-          return BaseLedger(params) as LedgerSignerMap[T];
-        default:
-          return EthereumLedger(params) as LedgerSignerMap[T];
-      }
-    }
+  return match(chain as LedgerSupportedChain)
+    .returnType<Promise<LedgerSignerMap[T]>>()
+    .with(Chain.THORChain, () =>
+      Promise.resolve(new THORChainLedger(derivationPath) as LedgerSignerMap[T]),
+    )
+    .with(Chain.Cosmos, () =>
+      Promise.resolve(new CosmosLedger(derivationPath) as LedgerSignerMap[T]),
+    )
+    .with(Chain.Bitcoin, () => Promise.resolve(BitcoinLedger(derivationPath) as LedgerSignerMap[T]))
+    .with(Chain.BitcoinCash, () =>
+      Promise.resolve(BitcoinCashLedger(derivationPath) as LedgerSignerMap[T]),
+    )
+    .with(Chain.Dash, () => Promise.resolve(DashLedger(derivationPath) as LedgerSignerMap[T]))
+    .with(Chain.Dogecoin, () =>
+      Promise.resolve(DogecoinLedger(derivationPath) as LedgerSignerMap[T]),
+    )
+    .with(Chain.Litecoin, () =>
+      Promise.resolve(LitecoinLedger(derivationPath) as LedgerSignerMap[T]),
+    )
+    .with(Chain.Ripple, () => Promise.resolve(XRPLedger(derivationPath) as LedgerSignerMap[T]))
+    .with(
+      Chain.Arbitrum,
+      Chain.Avalanche,
+      Chain.BinanceSmartChain,
+      Chain.Ethereum,
+      Chain.Optimism,
+      Chain.Polygon,
+      Chain.Base,
+      async () => {
+        const { getProvider } = await import("@swapkit/toolboxes/evm");
+        const params = { provider: await getProvider(chain as EVMChain), derivationPath };
 
-    default:
+        return match(chain as Chain)
+          .with(
+            Chain.BinanceSmartChain,
+            () => BinanceSmartChainLedger(params) as LedgerSignerMap[T],
+          )
+          .with(Chain.Avalanche, () => AvalancheLedger(params) as LedgerSignerMap[T])
+          .with(Chain.Arbitrum, () => ArbitrumLedger(params) as LedgerSignerMap[T])
+          .with(Chain.Optimism, () => OptimismLedger(params) as LedgerSignerMap[T])
+          .with(Chain.Polygon, () => PolygonLedger(params) as LedgerSignerMap[T])
+          .with(Chain.Base, () => BaseLedger(params) as LedgerSignerMap[T])
+          .otherwise(() => EthereumLedger(params) as LedgerSignerMap[T]);
+      },
+    )
+    .otherwise(() => {
       throw new SwapKitError("wallet_chain_not_supported", { wallet: WalletOption.LEDGER, chain });
-  }
+    });
 };

package/src/ledger/helpers/getLedgerTransport.ts

@@ -20,7 +20,9 @@ const getLedgerDevices = async () => {
   const existingDevices = devices.filter((d) => d.vendorId === ledgerUSBVendorId);
   if (existingDevices.length > 0) return existingDevices[0];
 
-  return navigatorUsb?.requestDevice({ filters: [{ vendorId: ledgerUSBVendorId }] });
+  return navigatorUsb?.requestDevice({
+    filters: [{ vendorId: ledgerUSBVendorId }],
+  });
 };
 
 export const getLedgerTransport = async () => {
@@ -57,9 +59,9 @@ export const getLedgerTransport = async () => {
     throw new SwapKitError("wallet_ledger_connection_claimed", error);
   }
 
-  const { default: Transport } = await import("@ledgerhq/hw-transport-webusb");
+  const Transport = (await import("@ledgerhq/hw-transport-webusb")).default;
   const isSupported = await Transport.isSupported();
-  if (!isSupported) throw new Error("WebUSB not supported");
+  if (!isSupported) throw new SwapKitError("wallet_ledger_webusb_not_supported");
 
   const { DisconnectedDevice } = await import("@ledgerhq/errors");
 

package/src/ledger/index.ts

@@ -6,6 +6,7 @@ import {
   type GenericTransferParams,
   SKConfig,
   StagenetChain,
+  SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
@@ -32,6 +33,7 @@ export const ledgerWallet = createWallet({
     Chain.Litecoin,
     Chain.Optimism,
     Chain.Polygon,
+    Chain.Ripple,
     Chain.THORChain,
   ],
   walletType: WalletOption.LEDGER,
@@ -148,7 +150,7 @@ async function getWalletMethods({
       const address = await getLedgerAddress({ chain, ledgerClient: signer });
 
       const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
-        if (!assetValue) throw new Error("invalid asset");
+        if (!assetValue) throw new SwapKitError("wallet_ledger_invalid_asset");
 
         const sendCoinsMessage = {
           amount: [
@@ -183,7 +185,7 @@ async function getWalletMethods({
     case Chain.THORChain: {
       const { SignMode } = await import("cosmjs-types/cosmos/tx/signing/v1beta1/signing.js");
       const { TxRaw } = await import("cosmjs-types/cosmos/tx/v1beta1/tx.js");
-      const { encodePubkey, makeAuthInfoBytes } = await import("@cosmjs/proto-signing");
+      const { encodePubkey, makeAuthInfoBytes } = (await import("@cosmjs/proto-signing")).default;
       const {
         createStargateClient,
         buildEncodedTxBody,
@@ -208,9 +210,9 @@ async function getWalletMethods({
         // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Refactor to reduce complexity
       }: GenericTransferParams | ThorchainDepositParams) => {
         const account = await toolbox.getAccount(address);
-        if (!account) throw new Error("invalid account");
-        if (!assetValue) throw new Error("invalid asset");
-        if (!value) throw new Error("Account pubkey not found");
+        if (!account) throw new SwapKitError("wallet_ledger_invalid_account");
+        if (!assetValue) throw new SwapKitError("wallet_ledger_invalid_asset");
+        if (!value) throw new SwapKitError("wallet_ledger_pubkey_not_found");
 
         const { accountNumber, sequence: sequenceNumber } = account;
         const sequence = (sequenceNumber || 0).toString();
@@ -230,7 +232,7 @@ async function getWalletMethods({
         });
 
         const signatures = await signTransaction(rawSendTx, sequence);
-        if (!signatures) throw new Error("tx signing failed");
+        if (!signatures) throw new SwapKitError("wallet_ledger_signing_error");
 
         const pubkey = encodePubkey({ type: "tendermint/PubKeySecp256k1", value });
         const msgs = orderedMessages.map(parseAminoMessageForDirectSigning);
@@ -267,7 +269,16 @@ async function getWalletMethods({
       return { ...toolbox, address, deposit, transfer, signMessage };
     }
 
+    case Chain.Ripple: {
+      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const address = signer.address;
+      const toolbox = await getRippleToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
     default:
-      throw new Error("Unsupported chain");
+      throw new SwapKitError("wallet_ledger_chain_not_supported", { chain });
   }
 }

package/src/ledger/interfaces/CosmosLedgerInterface.ts

@@ -32,7 +32,7 @@ export abstract class CosmosLedgerInterface {
         }
 
         case "cosmos": {
-          const { default: CosmosApp } = await import("@ledgerhq/hw-app-cosmos");
+          const CosmosApp = (await import("@ledgerhq/hw-app-cosmos")).default;
           this.ledgerApp =
             forceReconnect || !this.ledgerApp ? new CosmosApp(this.transport) : this.ledgerApp;
         }
@@ -58,7 +58,6 @@ export abstract class CosmosLedgerInterface {
         throw new SwapKitError("wallet_ledger_device_not_found");
 
       default: {
-        console.error(`Ledger error: ${errorCode} ${message}`);
         break;
       }
     }

package/src/okx/helpers.ts

@@ -3,16 +3,18 @@ import {
   ChainId,
   type EVMChain,
   SKConfig,
+  SwapKitError,
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
+import { Psbt } from "bitcoinjs-lib";
 import type { Eip1193Provider } from "ethers";
 
 const cosmosTransfer =
   () =>
   async ({ from, recipient, amount, asset, memo }: any) => {
     if (!(window.okxwallet && "keplr" in window.okxwallet)) {
-      throw new Error("No cosmos okxwallet found");
+      throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Cosmos });
     }
     const { createSigningStargateClient } = await import("@swapkit/toolboxes/cosmos");
 
@@ -38,7 +40,7 @@ async function getWeb3WalletMethods({
 }: { walletProvider: Eip1193Provider | undefined; chain: EVMChain }) {
   const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
   const { BrowserProvider } = await import("ethers");
-  if (!walletProvider) throw new Error("Requested web3 wallet is not installed");
+  if (!walletProvider) throw new SwapKitError("wallet_okx_not_found");
 
   const provider = new BrowserProvider(walletProvider, "any");
   const signer = await provider.getSigner();
@@ -49,7 +51,7 @@ async function getWeb3WalletMethods({
       await switchEVMWalletNetwork(provider, chain, toolbox.getNetworkParams());
     }
   } catch (_error) {
-    throw new Error(`Failed to add/switch ${chain} network: ${chain}`);
+    throw new SwapKitError("wallet_okx_failed_to_switch_network", { chain });
   }
 
   return prepareNetworkSwitch({ toolbox, provider, chain });
@@ -65,7 +67,7 @@ export async function getWalletMethods(chain: Chain) {
     case Chain.Polygon:
     case Chain.BinanceSmartChain: {
       if (!(window.okxwallet && "send" in window.okxwallet)) {
-        throw new Error("No okxwallet found");
+        throw new SwapKitError("wallet_okx_not_found", { chain });
       }
 
       const evmWallet = await getWeb3WalletMethods({
@@ -79,9 +81,9 @@ export async function getWalletMethods(chain: Chain) {
 
     case Chain.Bitcoin: {
       if (!(window.okxwallet && "bitcoin" in window.okxwallet)) {
-        throw new Error("No bitcoin okxwallet found");
+        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Bitcoin });
       }
-      const { Psbt } = await import("bitcoinjs-lib");
+
       const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
 
       const { bitcoin: wallet } = window.okxwallet;
@@ -106,13 +108,13 @@ export async function getWalletMethods(chain: Chain) {
 
     case Chain.Cosmos: {
       if (!(window.okxwallet && "keplr" in window.okxwallet)) {
-        throw new Error("No bitcoin okxwallet found");
+        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Cosmos });
       }
       const { keplr: wallet } = window.okxwallet;
 
       await wallet.enable(ChainId.Cosmos);
       const accounts = await wallet.getOfflineSignerOnlyAmino(ChainId.Cosmos).getAccounts();
-      if (!accounts?.[0]) throw new Error("No cosmos account found");
+      if (!accounts?.[0]) throw new SwapKitError("wallet_okx_no_accounts", { chain: Chain.Cosmos });
 
       const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
       const [{ address }] = accounts;
@@ -122,6 +124,6 @@ export async function getWalletMethods(chain: Chain) {
     }
 
     default:
-      throw new Error(`No wallet for chain ${chain}`);
+      throw new SwapKitError("wallet_okx_chain_not_supported", { chain });
   }
 }

package/src/onekey/index.ts

@@ -9,6 +9,7 @@ import {
   filterSupportedChains,
   prepareNetworkSwitch,
 } from "@swapkit/helpers";
+import { Psbt } from "bitcoinjs-lib";
 import type {
   BitcoinProvider,
   GetAddressOptions,
@@ -21,13 +22,9 @@ async function getWalletMethodsForExtension(chain: Chain) {
   switch (chain) {
     case Chain.Bitcoin: {
       if (!window.$onekey?.btc) {
-        throw new SwapKitError({
-          errorKey: "wallet_onekey_not_found",
-          info: { chain },
-        });
+        throw new SwapKitError({ errorKey: "wallet_onekey_not_found", info: { chain } });
       }
 
-      const { Psbt } = await import("bitcoinjs-lib");
       const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
       const {
         signTransaction: satsSignTransaction,
@@ -38,8 +35,7 @@ async function getWalletMethodsForExtension(chain: Chain) {
 
       let address = "";
 
-      const getProvider: () => Promise<BitcoinProvider | undefined> = () =>
-        new Promise((res) => res(window.$onekey?.btc as BitcoinProvider));
+      const getProvider = () => new Promise<BitcoinProvider>((res) => res(window.$onekey?.btc));
 
       const getAddressOptions: GetAddressOptions = {
         getProvider,

package/src/radix/index.ts

@@ -162,13 +162,13 @@ async function getWalletMethods() {
     const res = await rdt.walletApi.sendRequest();
 
     if (!res) {
-      throw new Error("wallet_radix_no_account");
+      throw new SwapKitError("wallet_radix_no_account");
     }
 
     const newAddress = res.unwrapOr(null)?.accounts[0]?.address;
 
     if (!newAddress) {
-      throw new Error("wallet_radix_no_account");
+      throw new SwapKitError("wallet_radix_no_account");
     }
 
     return newAddress;
@@ -182,7 +182,7 @@ async function getWalletMethods() {
     getAddress,
     getBalance: () => getBalance(address),
     transfer: (_params: { assetValue: AssetValue; recipient: string; from: string }) => {
-      throw new Error("Not implemented");
+      throw new SwapKitError("wallet_radix_method_not_supported", { method: "transfer" });
     },
     signAndBroadcast: async ({ manifest, message }: { manifest: string; message: string }) => {
       const tx = await rdt.walletApi.sendTransaction({
@@ -193,7 +193,7 @@ async function getWalletMethods() {
       const txResult = tx.unwrapOr(null)?.transactionIntentHash;
 
       if (!txResult) {
-        throw new Error("wallet_radix_transaction_failed");
+        throw new SwapKitError("wallet_radix_transaction_failed");
       }
 
       return txResult;

package/src/trezor/evmSigner.ts

@@ -35,7 +35,7 @@ export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEV
 
     getAddress = async () => {
       if (!this.address) {
-        const { default: TrezorConnect } = await import("@trezor/connect-web");
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
 
         const result = await TrezorConnect.ethereumGetAddress({
           path: derivationPathToString(this.derivationPath),
@@ -56,7 +56,7 @@ export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEV
     };
 
     signMessage = async (message: string) => {
-      const { default: TrezorConnect } = await import("@trezor/connect-web");
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
 
       const result = await TrezorConnect.ethereumSignMessage({
         path: derivationPathToString(this.derivationPath),
@@ -74,7 +74,7 @@ export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEV
     };
 
     signTypedData(): Promise<string> {
-      throw new Error("Not implemented");
+      throw new SwapKitError("wallet_trezor_method_not_supported", { method: "signTypedData" });
     }
 
     signTransaction = async ({
@@ -107,7 +107,7 @@ export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEV
         throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasPrice } });
       }
 
-      const { default: TrezorConnect } = await import("@trezor/connect-web");
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
       const { toHexString } = await import("@swapkit/toolboxes/evm");
       const { Transaction } = await import("ethers");
 

package/src/trezor/index.ts

@@ -68,7 +68,7 @@ async function getTrezorWallet<T extends Chain>({
       const coin = chain.toLowerCase();
 
       const getAddress = async (path: DerivationPathArray = derivationPath) => {
-        const { default: TrezorConnect } = await import("@trezor/connect-web");
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
         const { success, payload } = await TrezorConnect.getAddress({
           path: derivationPathToString(path),
           coin,
@@ -95,7 +95,7 @@ async function getTrezorWallet<T extends Chain>({
       const address = await getAddress();
 
       const signTransaction = async (psbt: Psbt, inputs: UTXOType[], memo = "") => {
-        const { default: TrezorConnect } = await import("@trezor/connect-web");
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
         const address_n = derivationPath.map((pathElement, index) =>
           index < 3 ? ((pathElement as number) | 0x80000000) >>> 0 : (pathElement as number),
         );
@@ -229,11 +229,21 @@ export const trezorWallet = createWallet({
         });
       }
 
-      const { default: TrezorConnect } = await import("@trezor/connect-web");
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
       const { success } = await TrezorConnect.getDeviceState();
 
       if (!success) {
-        const manifest = SKConfig.get("integrations").trezor || { appUrl: "", email: "" };
+        const trezorConfig = SKConfig.get("integrations").trezor;
+        const manifest = trezorConfig
+          ? {
+              ...trezorConfig,
+              appName: (trezorConfig as any).appName || "SwapKit",
+            }
+          : {
+              appUrl: "",
+              email: "",
+              appName: "SwapKit",
+            };
         TrezorConnect.init({ lazyLoad: true, manifest });
       }
 

package/src/types.ts

@@ -12,6 +12,7 @@ import type { BrowserProvider, Eip1193Provider } from "ethers";
 import type { SubstrateInjectedExtension } from "@swapkit/toolboxes/substrate";
 import type { bitgetWallet } from "./bitget";
 import type { coinbaseWallet } from "./coinbase";
+import type { cosmostationWallet } from "./cosmostation";
 import type { ctrlWallet } from "./ctrl";
 import type { evmWallet } from "./evm-extensions";
 import type { exodusWallet } from "./exodus";
@@ -34,6 +35,7 @@ export type SKWallets = {
   [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 exodusWallet;
@@ -64,6 +66,7 @@ export type SKWalletsSupportedChains = {
   [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 exodusWallet.connectExodusWallet.supportedChains;

package/src/utils.ts

@@ -25,6 +25,10 @@ export async function loadWallet<W extends WalletOption>(walletOption: W): Promi
       async () => (await import("./walletconnect")).walletconnectWallet,
     )
     .with(WalletOption.KEPLR, WalletOption.LEAP, async () => (await import("./keplr")).keplrWallet)
+    .with(
+      WalletOption.COSMOSTATION,
+      async () => (await import("./cosmostation")).cosmostationWallet,
+    )
     .with(
       WalletOption.BRAVE,
       WalletOption.COINBASE_WEB,