@swapkit/wallets 3.0.0-beta.3 → 3.0.0-beta.30

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 {
@@ -10,6 +16,7 @@ import {
   OptimismLedger,
   PolygonLedger,
 } from "../clients/evm";
+import { getNearLedgerClient } from "../clients/near";
 import { THORChainLedger } from "../clients/thorchain";
 import {
   BitcoinCashLedger,
@@ -18,6 +25,8 @@ import {
   DogecoinLedger,
   LitecoinLedger,
 } from "../clients/utxo";
+import { XRPLedger } from "../clients/xrp";
+import { getLedgerTransport } from "./getLedgerTransport";
 
 type LedgerSignerMap = {
   [Chain.Arbitrum]: ReturnType<typeof ArbitrumLedger>;
@@ -31,8 +40,10 @@ type LedgerSignerMap = {
   [Chain.Dogecoin]: ReturnType<typeof DogecoinLedger>;
   [Chain.Ethereum]: ReturnType<typeof EthereumLedger>;
   [Chain.Litecoin]: ReturnType<typeof LitecoinLedger>;
+  [Chain.Near]: Awaited<ReturnType<typeof getNearLedgerClient>>;
   [Chain.Optimism]: ReturnType<typeof OptimismLedger>;
   [Chain.Polygon]: ReturnType<typeof PolygonLedger>;
+  [Chain.Ripple]: ReturnType<typeof XRPLedger>;
   [Chain.THORChain]: THORChainLedger;
 };
 
@@ -45,51 +56,58 @@ 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.Near, async () => {
+      const transport = await getLedgerTransport();
+      return getNearLedgerClient(transport, derivationPath) as unknown 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,
@@ -30,8 +31,10 @@ export const ledgerWallet = createWallet({
     Chain.Dogecoin,
     Chain.Ethereum,
     Chain.Litecoin,
+    Chain.Near,
     Chain.Optimism,
     Chain.Polygon,
+    Chain.Ripple,
     Chain.THORChain,
   ],
   walletType: WalletOption.LEDGER,
@@ -148,7 +151,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 +186,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 +211,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 +233,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 +270,25 @@ async function getWalletMethods({
       return { ...toolbox, address, deposit, transfer, signMessage };
     }
 
+    case Chain.Near: {
+      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
+      const signer = await getLedgerClient({ chain, derivationPath });
+      const accountId = await signer.getAddress();
+      const toolbox = await getNearToolbox({ signer });
+
+      return { ...toolbox, address: accountId };
+    }
+
+    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;
@@ -121,7 +123,23 @@ export async function getWalletMethods(chain: Chain) {
       return { ...toolbox, address, transfer: cosmosTransfer() };
     }
 
+    case Chain.Near: {
+      if (!(window.okxwallet && "near" in window.okxwallet)) {
+        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Near });
+      }
+
+      const { createNearSignerFromProvider } = await import("../helpers/near");
+      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
+
+      const provider = window.okxwallet.near;
+      const signer = await createNearSignerFromProvider(provider, "OKX");
+      const accountId = await signer.getAddress();
+      const toolbox = await getNearToolbox({ signer });
+
+      return { ...toolbox, address: accountId };
+    }
+
     default:
-      throw new Error(`No wallet for chain ${chain}`);
+      throw new SwapKitError("wallet_okx_chain_not_supported", { chain });
   }
 }

package/src/okx/index.ts

@@ -14,6 +14,7 @@ export const okxWallet = createWallet({
     Chain.Bitcoin,
     Chain.Cosmos,
     Chain.Ethereum,
+    Chain.Near,
     Chain.Optimism,
     Chain.Polygon,
   ],

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,9 +12,11 @@ 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";
+import type { NearBrowserWalletProvider } from "./helpers/near";
 import type { keepkeyWallet } from "./keepkey";
 import type { keepkeyBexWallet } from "./keepkey-bex";
 import type { keplrWallet } from "./keplr";
@@ -34,6 +36,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 +67,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;
@@ -119,6 +123,7 @@ declare global {
       thorchain: Eip1193Provider;
       mayachain: Eip1193Provider;
       solana: SolanaProvider & { isXDEFI: boolean };
+      near: NearBrowserWalletProvider;
     };
 
     bitkeep?: {
@@ -193,6 +198,15 @@ declare global {
             ) => Promise<boolean>;
             getOfflineSignerOnlyAmino: (chainId: string) => OfflineAminoSigner;
           };
+          near: NearBrowserWalletProvider & {
+            requestSignIn: (params?: {
+              contractId?: string;
+              methodNames?: string[];
+            }) => Promise<{ accountId: string; accessKey?: any }>;
+            requestSignTransactions: (params: {
+              transactions: any[];
+            }) => Promise<any>;
+          };
         }
       | EthereumWindowProvider;
   }

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,

package/src/walletconnect/constants.ts

@@ -13,6 +13,8 @@ export const ARBITRUM_ONE_MAINNET_ID = "eip155:42161";
 export const OPTIMISM_MAINNET_ID = "eip155:10";
 export const POLYGON_MAINNET_ID = "eip155:137";
 export const BASE_MAINNET_ID = "eip155:8453";
+export const NEAR_MAINNET_ID = "near:mainnet";
+export const NEAR_TESTNET_ID = "near:testnet";
 
 export const DEFAULT_LOGGER = "debug";
 

package/src/walletconnect/evmSigner.ts

@@ -33,7 +33,7 @@ class WalletconnectSigner extends AbstractSigner {
       throw new SwapKitError("wallet_walletconnect_connection_not_established");
     }
     if (!this.address) {
-      this.address = getAddressByChain(this.chain, this.walletconnect.accounts);
+      this.address = getAddressByChain(this.chain, this.walletconnect.accounts || []);
     }
 
     return this.address;
@@ -43,7 +43,7 @@ class WalletconnectSigner extends AbstractSigner {
     // this is probably broken
     const txHash = (await this.walletconnect?.client.request({
       chainId: chainToChainId(this.chain),
-      topic: this.walletconnect.session.topic,
+      topic: this.walletconnect.session.topic || "",
       request: {
         method: DEFAULT_EIP155_METHODS.ETH_SIGN,
         params: [message],
@@ -54,7 +54,9 @@ class WalletconnectSigner extends AbstractSigner {
   };
 
   signTransaction = () => {
-    throw new Error("Not implemented: signTransaction");
+    throw new SwapKitError("wallet_walletconnect_method_not_supported", {
+      method: "signTransaction",
+    });
 
     // const baseTx = {
     //   from,
@@ -77,7 +79,9 @@ class WalletconnectSigner extends AbstractSigner {
 
   // ANCHOR (@Towan) - Implement in future
   signTypedData = () => {
-    throw new Error("Not implemented: signTypedData");
+    throw new SwapKitError("wallet_walletconnect_method_not_supported", {
+      method: "signTypedData",
+    });
 
     // const { toHexString } = await import('@swapkit/toolboxes/evm');
 

package/src/walletconnect/helpers.ts

@@ -1,4 +1,4 @@
-import { Chain, type EVMChain } from "@swapkit/helpers";
+import { Chain, type EVMChain, SKConfig } from "@swapkit/helpers";
 
 import {
   ARBITRUM_ONE_MAINNET_ID,
@@ -9,13 +9,15 @@ import {
   ETHEREUM_MAINNET_ID,
   KUJIRA_MAINNET_ID,
   MAYACHAIN_MAINNET_ID,
+  NEAR_MAINNET_ID,
+  NEAR_TESTNET_ID,
   OPTIMISM_MAINNET_ID,
   POLYGON_MAINNET_ID,
   THORCHAIN_MAINNET_ID,
 } from "./constants";
 
 export const getAddressByChain = (
-  chain: EVMChain | Chain.THORChain | Chain.Maya | Chain.Kujira | Chain.Cosmos,
+  chain: EVMChain | Chain.THORChain | Chain.Maya | Chain.Kujira | Chain.Cosmos | Chain.Near,
   accounts: string[],
 ) => {
   const account = accounts.find((account) => account.startsWith(chainToChainId(chain))) || "";
@@ -48,6 +50,11 @@ export const chainToChainId = (chain: Chain) => {
       return COSMOS_HUB_MAINNET_ID;
     case Chain.Kujira:
       return KUJIRA_MAINNET_ID;
+    case Chain.Near: {
+      // Use testnet if stagenet is enabled
+      const { isStagenet } = SKConfig.get("envs");
+      return isStagenet ? NEAR_TESTNET_ID : NEAR_MAINNET_ID;
+    }
     default:
       return "";
   }