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

package/src/trezor/index.ts

@@ -2,6 +2,7 @@ import {
   Chain,
   type DerivationPathArray,
   FeeOption,
+  type GenericTransferParams,
   SKConfig,
   SwapKitError,
   WalletOption,
@@ -9,8 +10,9 @@ import {
   derivationPathToString,
   filterSupportedChains,
 } from "@swapkit/helpers";
-import type { Psbt, UTXOTransferParams, UTXOType } from "@swapkit/toolboxes/utxo";
-import { getWalletSupportedChains } from "../helpers";
+import type { UTXOToolboxes, UTXOType } from "@swapkit/toolboxes/utxo";
+import type { Psbt } from "bitcoinjs-lib";
+import { getWalletSupportedChains } from "../utils";
 
 function getScriptType(derivationPath: DerivationPathArray) {
   switch (derivationPath[0]) {
@@ -25,10 +27,10 @@ function getScriptType(derivationPath: DerivationPathArray) {
   }
 }
 
-async function getToolbox({
+async function getTrezorWallet<T extends Chain>({
   chain,
   derivationPath,
-}: { chain: Chain; derivationPath: DerivationPathArray }) {
+}: { chain: T; derivationPath: DerivationPathArray }) {
   switch (chain) {
     case Chain.BinanceSmartChain:
     case Chain.Avalanche:
@@ -37,15 +39,15 @@ async function getToolbox({
     case Chain.Polygon:
     case Chain.Base:
     case Chain.Ethereum: {
-      const { getProvider, getToolboxByChain } = await import("@swapkit/toolboxes/evm");
+      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
       const { getEVMSigner } = await import("./evmSigner");
 
-      const provider = getProvider(chain);
+      const provider = await getProvider(chain);
       const signer = await getEVMSigner({ chain, derivationPath, provider });
       const address = await signer.getAddress();
-      const toolbox = getToolboxByChain(chain)({ provider, signer });
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
 
-      return { address, walletMethods: toolbox };
+      return { ...toolbox, address };
     }
 
     case Chain.Bitcoin:
@@ -53,10 +55,7 @@ async function getToolbox({
     case Chain.Dash:
     case Chain.Dogecoin:
     case Chain.Litecoin: {
-      const { toCashAddress, getToolboxByChain, BCHToolbox } = await import(
-        "@swapkit/toolboxes/utxo"
-      );
-
+      const { toCashAddress, getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
       const scriptType = getScriptType(derivationPath);
 
       if (!scriptType) {
@@ -67,7 +66,6 @@ async function getToolbox({
       }
 
       const coin = chain.toLowerCase();
-      const toolbox = getToolboxByChain(chain)();
 
       const getAddress = async (path: DerivationPathArray = derivationPath) => {
         const { default: TrezorConnect } = await import("@trezor/connect-web");
@@ -86,9 +84,12 @@ async function getToolbox({
           });
         }
 
-        return chain === Chain.BitcoinCash
-          ? (toolbox as ReturnType<typeof BCHToolbox>).stripPrefix(payload.address)
-          : payload.address;
+        if (chain === Chain.BitcoinCash) {
+          const toolbox = await getUtxoToolbox(chain as Chain.BitcoinCash);
+          return toolbox.stripPrefix(payload.address);
+        }
+
+        return payload.address;
       };
 
       const address = await getAddress();
@@ -98,32 +99,28 @@ async function getToolbox({
         const address_n = derivationPath.map((pathElement, index) =>
           index < 3 ? ((pathElement as number) | 0x80000000) >>> 0 : (pathElement as number),
         );
+        const toolbox = await getUtxoToolbox(chain as Chain.BitcoinCash);
 
         const result = await TrezorConnect.signTransaction({
           coin,
-          inputs: inputs.map((input) => ({
+          inputs: inputs.map(({ hash, index, value }) => ({
             // Hardens the first 3 elements of the derivation path - required by trezor
             address_n,
-            prev_hash: input.hash,
-            prev_index: input.index,
+            prev_hash: hash,
+            prev_index: index,
             // object needs amount but does not use it for signing
-            amount: input.value,
+            amount: value,
             script_type: scriptType.input,
           })),
 
           // Lint is not happy with the type of txOutputs
-          // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor
           outputs: psbt.txOutputs.map((output: any) => {
             const outputAddress =
               chain === Chain.BitcoinCash && output.address
-                ? toCashAddress(output.address)
+                ? toolbox.stripPrefix(toCashAddress(output.address))
                 : output.address;
 
-            // Strip prefix from BCH address to compare with stripped address from Trezor
-            const isChangeAddress =
-              chain === Chain.BitcoinCash && outputAddress
-                ? (toolbox as ReturnType<typeof BCHToolbox>).stripPrefix(outputAddress) === address
-                : outputAddress === address;
+            const isChangeAddress = outputAddress === address;
 
             // OP_RETURN
             if (!output.address) {
@@ -134,17 +131,13 @@ async function getToolbox({
               };
             }
 
-            // Change Address
-            if (isChangeAddress) {
-              return { address_n, amount: output.value, script_type: scriptType.output };
-            }
-
-            // Outgoing UTXO
-            return { address: outputAddress, amount: output.value, script_type: "PAYTOADDRESS" };
+            return isChangeAddress
+              ? { amount: output.value, address_n, script_type: scriptType.output }
+              : { amount: output.value, address: outputAddress, script_type: "PAYTOADDRESS" };
           }),
         });
 
-        if (result.success && result.payload?.serializedTx) {
+        if (result.success) {
           return result.payload.serializedTx;
         }
 
@@ -158,30 +151,36 @@ async function getToolbox({
       };
 
       const transfer = async ({
-        from,
         recipient,
         feeOptionKey,
         feeRate: paramFeeRate,
         memo,
         ...rest
-      }: UTXOTransferParams) => {
-        if (!(from && recipient)) {
+      }: GenericTransferParams) => {
+        if (!(address && recipient)) {
           throw new SwapKitError({
             errorKey: "wallet_missing_params",
-            info: { wallet: WalletOption.TREZOR, memo, from, recipient },
+            info: { wallet: WalletOption.TREZOR, memo, address, recipient },
           });
         }
 
+        const toolbox = await getUtxoToolbox(chain);
+
         const feeRate =
           paramFeeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast];
 
-        const { psbt, inputs } = await toolbox.buildTx({
+        const createTxMethod =
+          chain === Chain.BitcoinCash
+            ? (toolbox as UTXOToolboxes["BCH"]).buildTx
+            : (toolbox as UTXOToolboxes["BTC"]).createTransaction;
+
+        const { psbt, inputs } = await createTxMethod({
           ...rest,
           memo,
           recipient,
           feeRate,
-          sender: from,
-          fetchTxHex: chain === Chain.Dogecoin,
+          sender: address,
+          fetchTxHex: true,
         });
 
         const txHex = await signTransaction(psbt, inputs, memo);
@@ -190,7 +189,9 @@ async function getToolbox({
         return tx;
       };
 
-      return { address, walletMethods: { ...toolbox, transfer, signTransaction } };
+      const toolbox = await getUtxoToolbox(chain);
+
+      return { ...toolbox, address, transfer, signTransaction };
     }
 
     default:
@@ -236,9 +237,9 @@ export const trezorWallet = createWallet({
         TrezorConnect.init({ lazyLoad: true, manifest });
       }
 
-      const { address, walletMethods } = await getToolbox({ chain, derivationPath });
+      const wallet = await getTrezorWallet({ chain, derivationPath });
 
-      addChain({ ...walletMethods, address, balance: [], chain, walletType });
+      addChain({ ...wallet, chain, walletType });
 
       return true;
     },

package/src/types.ts

@@ -0,0 +1,199 @@
+import type {
+  AminoSignResponse,
+  OfflineAminoSigner,
+  StdSignDoc,
+  StdSignature,
+} from "@cosmjs/amino";
+import type { Keplr } from "@keplr-wallet/types";
+import { type EthereumWindowProvider, WalletOption } from "@swapkit/helpers";
+import type { SolanaProvider } from "@swapkit/toolboxes/solana";
+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 { ctrlWallet } from "./ctrl";
+import type { evmWallet } from "./evm-extensions";
+import type { exodusWallet } from "./exodus";
+import type { keepkeyWallet } from "./keepkey";
+import type { keepkeyBexWallet } from "./keepkey-bex";
+import type { keplrWallet } from "./keplr";
+import type { keystoreWallet } from "./keystore";
+import type { ledgerWallet } from "./ledger";
+import type { okxWallet } from "./okx";
+import type { onekeyWallet } from "./onekey";
+import type { phantomWallet } from "./phantom";
+import type { polkadotWallet } from "./polkadotjs";
+import type { radixWallet } from "./radix";
+import type { talismanWallet } from "./talisman";
+import type { trezorWallet } from "./trezor";
+import type { walletconnectWallet } from "./walletconnect";
+
+export type SKWallets = {
+  [WalletOption.BITGET]: typeof bitgetWallet;
+  [WalletOption.BRAVE]: typeof evmWallet;
+  [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet;
+  [WalletOption.COINBASE_WEB]: typeof evmWallet;
+  [WalletOption.CTRL]: typeof ctrlWallet;
+  [WalletOption.EIP6963]: typeof evmWallet;
+  [WalletOption.EXODUS]: typeof exodusWallet;
+  [WalletOption.KEEPKEY]: typeof keepkeyWallet;
+  [WalletOption.KEEPKEY_BEX]: typeof keepkeyBexWallet;
+  [WalletOption.KEPLR]: typeof keplrWallet;
+  [WalletOption.KEYSTORE]: typeof keystoreWallet;
+  [WalletOption.LEAP]: typeof keplrWallet;
+  [WalletOption.LEDGER]: typeof ledgerWallet;
+  [WalletOption.LEDGER_LIVE]: typeof ledgerWallet;
+  [WalletOption.METAMASK]: typeof evmWallet;
+  [WalletOption.OKX]: typeof okxWallet;
+  [WalletOption.OKX_MOBILE]: typeof evmWallet;
+  [WalletOption.ONEKEY]: typeof onekeyWallet;
+  [WalletOption.PHANTOM]: typeof phantomWallet;
+  [WalletOption.POLKADOT_JS]: typeof polkadotWallet;
+  [WalletOption.RADIX_WALLET]: typeof radixWallet;
+  [WalletOption.TALISMAN]: typeof talismanWallet;
+  [WalletOption.TREZOR]: typeof trezorWallet;
+  [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet;
+  [WalletOption.WALLETCONNECT]: typeof walletconnectWallet;
+};
+
+export type SKConnectWallets = SKWallets[keyof SKWallets];
+
+export type SKWalletsSupportedChains = {
+  [WalletOption.BITGET]: typeof bitgetWallet.connectBitget.supportedChains;
+  [WalletOption.BRAVE]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.COINBASE_MOBILE]: typeof coinbaseWallet.connectCoinbaseWallet.supportedChains;
+  [WalletOption.COINBASE_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.CTRL]: typeof ctrlWallet.connectCtrl.supportedChains;
+  [WalletOption.EIP6963]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.EXODUS]: typeof exodusWallet.connectExodusWallet.supportedChains;
+  [WalletOption.KEEPKEY]: typeof keepkeyWallet.connectKeepkey.supportedChains;
+  [WalletOption.KEEPKEY_BEX]: typeof keepkeyBexWallet.connectKeepkeyBex.supportedChains;
+  [WalletOption.KEPLR]: typeof keplrWallet.connectKeplr.supportedChains;
+  [WalletOption.KEYSTORE]: typeof keystoreWallet.connectKeystore.supportedChains;
+  [WalletOption.LEAP]: typeof keplrWallet.connectKeplr.supportedChains;
+  [WalletOption.LEDGER]: typeof ledgerWallet.connectLedger.supportedChains;
+  [WalletOption.LEDGER_LIVE]: typeof ledgerWallet.connectLedger.supportedChains;
+  [WalletOption.METAMASK]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.OKX]: typeof okxWallet.connectOkx.supportedChains;
+  [WalletOption.OKX_MOBILE]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.ONEKEY]: typeof onekeyWallet.connectOnekeyWallet.supportedChains;
+  [WalletOption.PHANTOM]: typeof phantomWallet.connectPhantom.supportedChains;
+  [WalletOption.POLKADOT_JS]: typeof polkadotWallet.connectPolkadotJs.supportedChains;
+  [WalletOption.RADIX_WALLET]: typeof radixWallet.connectRadixWallet.supportedChains;
+  [WalletOption.TALISMAN]: typeof talismanWallet.connectTalisman.supportedChains;
+  [WalletOption.TREZOR]: typeof trezorWallet.connectTrezor.supportedChains;
+  [WalletOption.TRUSTWALLET_WEB]: typeof evmWallet.connectEVMWallet.supportedChains;
+  [WalletOption.WALLETCONNECT]: typeof walletconnectWallet.connectWalletconnect.supportedChains;
+};
+
+type UnisatToSignInputs = {
+  index: number;
+  sighashTypes?: number[];
+  disableTweakSigner?: boolean;
+} & ({ address: string } | { publicKey: string });
+
+declare global {
+  interface Window {
+    injectedWeb3?: SubstrateInjectedExtension;
+    talismanEth?: EthereumWindowProvider;
+    $onekey?: any;
+    braveSolana: any;
+    coinbaseWalletExtension: EthereumWindowProvider;
+    ethereum: EthereumWindowProvider;
+    keplr: Keplr;
+    leap: Keplr;
+    trustwallet: EthereumWindowProvider;
+    phantom: {
+      solana: SolanaProvider;
+    };
+
+    xfi?: {
+      binance: Eip1193Provider;
+      bitcoin: Eip1193Provider;
+      bitcoincash: Eip1193Provider;
+      dogecoin: Eip1193Provider;
+      ethereum: BrowserProvider;
+      keplr: Keplr;
+      litecoin: Eip1193Provider;
+      thorchain: Eip1193Provider;
+      mayachain: Eip1193Provider;
+      solana: SolanaProvider & { isXDEFI: boolean };
+    };
+
+    bitkeep?: {
+      unisat: {
+        requestAccounts: () => Promise<[string, ...string[]]>;
+        signMessage: (message: string, type?: "ecdsa" | "bip322-simple") => Promise<string>;
+        signPsbt: (
+          psbtHex: string,
+          {
+            autoFinalized,
+            toSignInputs,
+          }: { autoFinalized?: boolean; toSignInputs?: UnisatToSignInputs[] },
+        ) => Promise<string>;
+      };
+      keplr: {
+        enable: (chainId: string | string[]) => Promise<void>;
+        signAmino: (
+          chainId: string,
+          signer: string,
+          signDoc: StdSignDoc,
+          signOptions: any,
+        ) => Promise<AminoSignResponse>;
+        signArbitrary: (
+          chainId: string,
+          signer: string,
+          data: string | Uint8Array,
+        ) => Promise<StdSignature>;
+        verifyArbitrary: (
+          chainId: string,
+          signer: string,
+          data: string | Uint8Array,
+          signature: StdSignature,
+        ) => Promise<boolean>;
+        getOfflineSignerOnlyAmino: (chainId: string) => OfflineAminoSigner;
+      };
+      solana: SolanaProvider;
+      ethereum: EthereumWindowProvider;
+    };
+
+    okxwallet?:
+      | {
+          bitcoin: {
+            connect: () => Promise<{
+              address: string;
+              publicKey: string;
+            }>;
+            disconnect: () => Promise<void>;
+            signMessage: (message: string, { from }: { from: string }) => Promise<string>;
+            signPsbt: (
+              psbtHex: string,
+              { from, type }: { from: string; type: string },
+            ) => Promise<string>;
+          };
+          keplr: {
+            enable: (chainId: string | string[]) => Promise<void>;
+            signAmino: (
+              chainId: string,
+              signer: string,
+              signDoc: StdSignDoc,
+              signOptions: any,
+            ) => Promise<AminoSignResponse>;
+            signArbitrary: (
+              chainId: string,
+              signer: string,
+              data: string | Uint8Array,
+            ) => Promise<StdSignature>;
+            verifyArbitrary: (
+              chainId: string,
+              signer: string,
+              data: string | Uint8Array,
+              signature: StdSignature,
+            ) => Promise<boolean>;
+            getOfflineSignerOnlyAmino: (chainId: string) => OfflineAminoSigner;
+          };
+        }
+      | EthereumWindowProvider;
+  }
+}

package/src/utils.ts

@@ -0,0 +1,54 @@
+import { WalletOption, type createWallet } from "@swapkit/helpers";
+import type { SKWallets } from "./types";
+
+export function getWalletSupportedChains<
+  T extends ReturnType<typeof createWallet<any, any, any, any>>,
+>(wallet: T): T[keyof T]["supportedChains"] {
+  const walletName = Object.keys(wallet)?.[0] || "";
+  return wallet?.[walletName]?.supportedChains || [];
+}
+
+export async function loadWallet<W extends WalletOption>(walletOption: W): Promise<SKWallets[W]> {
+  const { match } = await import("ts-pattern");
+
+  const wallet = await match(walletOption as WalletOption)
+    .with(WalletOption.COINBASE_MOBILE, async () => (await import("./coinbase")).coinbaseWallet)
+    .with(WalletOption.BITGET, async () => (await import("./bitget")).bitgetWallet)
+    .with(WalletOption.CTRL, async () => (await import("./ctrl")).ctrlWallet)
+    .with(WalletOption.OKX, async () => (await import("./okx")).okxWallet)
+    .with(WalletOption.ONEKEY, async () => (await import("./onekey")).onekeyWallet)
+    .with(WalletOption.EXODUS, async () => (await import("./exodus")).exodusWallet)
+    .with(WalletOption.KEEPKEY, async () => (await import("./keepkey")).keepkeyWallet)
+    .with(WalletOption.KEEPKEY_BEX, async () => (await import("./keepkey-bex")).keepkeyBexWallet)
+    .with(
+      WalletOption.WALLETCONNECT,
+      async () => (await import("./walletconnect")).walletconnectWallet,
+    )
+    .with(WalletOption.KEPLR, WalletOption.LEAP, async () => (await import("./keplr")).keplrWallet)
+    .with(
+      WalletOption.BRAVE,
+      WalletOption.COINBASE_WEB,
+      WalletOption.EIP6963,
+      WalletOption.METAMASK,
+      WalletOption.OKX_MOBILE,
+      WalletOption.TRUSTWALLET_WEB,
+      async () => (await import("./evm-extensions")).evmWallet,
+    )
+
+    .with(WalletOption.KEYSTORE, async () => (await import("./keystore")).keystoreWallet)
+    .with(WalletOption.TREZOR, async () => (await import("./trezor")).trezorWallet)
+    .with(
+      WalletOption.LEDGER,
+      // TODO: Remove
+      WalletOption.LEDGER_LIVE,
+      async () => (await import("./ledger")).ledgerWallet,
+    )
+
+    .with(WalletOption.PHANTOM, async () => (await import("./phantom")).phantomWallet)
+    .with(WalletOption.POLKADOT_JS, async () => (await import("./polkadotjs")).polkadotWallet)
+    .with(WalletOption.RADIX_WALLET, async () => (await import("./radix")).radixWallet)
+    .with(WalletOption.TALISMAN, async () => (await import("./talisman")).talismanWallet)
+    .exhaustive();
+
+  return wallet as SKWallets[W];
+}

package/src/walletconnect/constants.ts

@@ -4,7 +4,7 @@ export const DEFAULT_RELAY_URL = "wss://relay.walletconnect.com";
 
 export const ETHEREUM_MAINNET_ID = "eip155:1";
 export const BSC_MAINNET_ID = "eip155:56";
-export const AVALACHE_MAINNET_ID = "eip155:43114";
+export const AVALANCHE_MAINNET_ID = "eip155:43114";
 export const THORCHAIN_MAINNET_ID = "cosmos:thorchain";
 export const COSMOS_HUB_MAINNET_ID = "cosmos:cosmoshub-4";
 export const KUJIRA_MAINNET_ID = "cosmos:kaiyo-1";

package/src/walletconnect/helpers.ts

@@ -2,7 +2,7 @@ import { Chain, type EVMChain } from "@swapkit/helpers";
 
 import {
   ARBITRUM_ONE_MAINNET_ID,
-  AVALACHE_MAINNET_ID,
+  AVALANCHE_MAINNET_ID,
   BASE_MAINNET_ID,
   BSC_MAINNET_ID,
   COSMOS_HUB_MAINNET_ID,
@@ -27,7 +27,7 @@ export const getAddressByChain = (
 export const chainToChainId = (chain: Chain) => {
   switch (chain) {
     case Chain.Avalanche:
-      return AVALACHE_MAINNET_ID;
+      return AVALANCHE_MAINNET_ID;
     case Chain.Base:
       return BASE_MAINNET_ID;
     case Chain.BinanceSmartChain:

package/src/walletconnect/index.ts

@@ -2,21 +2,18 @@ import type { StdSignDoc } from "@cosmjs/amino";
 import {
   Chain,
   ChainId,
+  type GenericTransferParams,
   SKConfig,
   SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
 } from "@swapkit/helpers";
-import type {
-  BaseCosmosToolboxType,
-  DepositParam,
-  TransferParams,
-} from "@swapkit/toolboxes/cosmos";
+import type { ThorchainDepositParams, createThorchainToolbox } from "@swapkit/toolboxes/cosmos";
 import type { WalletConnectModalSign } from "@walletconnect/modal-sign-html";
 import type { SessionTypes, SignClientTypes } from "@walletconnect/types";
 
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 import {
   DEFAULT_APP_METADATA,
   DEFAULT_COSMOS_METHODS,
@@ -76,31 +73,12 @@ export const walletconnectWallet = createWallet({
           const address = getAddressByChain(chain, accounts);
           const toolbox = await getToolbox({ session, address, chain, walletconnect });
 
-          async function getAccount(accountAddress: string) {
-            const account = await (toolbox as BaseCosmosToolboxType).getAccount(accountAddress);
-            const [{ address, algo, pubkey }] = (await walletconnect?.client.request({
-              chainId: THORCHAIN_MAINNET_ID,
-              topic: session.topic,
-              request: {
-                method: DEFAULT_COSMOS_METHODS.COSMOS_GET_ACCOUNTS,
-                params: {},
-              },
-            })) as [{ address: string; algo: string; pubkey: string }];
-
-            return { ...account, address, pubkey: { type: algo, value: pubkey } };
-          }
-
           addChain({
             ...toolbox,
             address,
-            balance: [],
             chain,
             disconnect: walletconnect.disconnect,
             walletType: WalletOption.WALLETCONNECT,
-            getAccount:
-              chain === Chain.THORChain
-                ? getAccount
-                : (toolbox as BaseCosmosToolboxType).getAccount,
           });
         }),
       );
@@ -131,13 +109,13 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
     case Chain.Ethereum:
     case Chain.Optimism:
     case Chain.Polygon: {
-      const { getProvider, getToolboxByChain } = await import("@swapkit/toolboxes/evm");
+      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
 
-      const provider = getProvider(chain);
+      const provider = await getProvider(chain);
       const signer = await getEVMSigner({ walletconnect, chain, provider });
-      const toolbox = getToolboxByChain(chain);
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
 
-      return toolbox({ provider, signer });
+      return toolbox;
     }
 
     case Chain.THORChain: {
@@ -146,7 +124,7 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
       const { encodePubkey, makeAuthInfoBytes } = await import("@cosmjs/proto-signing");
       const { makeSignDoc } = await import("@cosmjs/amino");
       const {
-        ThorchainToolbox,
+        getCosmosToolbox,
         buildAminoMsg,
         buildEncodedTxBody,
         createStargateClient,
@@ -154,7 +132,29 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
         getDefaultChainFee,
         parseAminoMessageForDirectSigning,
       } = await import("@swapkit/toolboxes/cosmos");
-      const toolbox = ThorchainToolbox();
+      const toolbox = await getCosmosToolbox(Chain.THORChain);
+
+      async function getAccount(accountAddress: string) {
+        const cosmosToolbox = toolbox;
+        const account = await (
+          cosmosToolbox as Awaited<ReturnType<typeof createThorchainToolbox>>
+        ).getAccount(accountAddress);
+
+        if (chain !== Chain.THORChain) {
+          return account;
+        }
+
+        const [{ address, algo, pubkey }] = (await walletconnect?.client.request({
+          chainId: THORCHAIN_MAINNET_ID,
+          topic: session.topic,
+          request: {
+            method: DEFAULT_COSMOS_METHODS.COSMOS_GET_ACCOUNTS,
+            params: {},
+          },
+        })) as [{ address: string; algo: string; pubkey: string }];
+
+        return { ...account, address, pubkey: { type: algo, value: pubkey } };
+      }
 
       const fee = getDefaultChainFee(chain);
 
@@ -172,7 +172,7 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
         assetValue,
         memo,
         ...rest
-      }: TransferParams | DepositParam) {
+      }: GenericTransferParams | ThorchainDepositParams) {
         const account = await toolbox.getAccount(address);
         if (!account) {
           throw new SwapKitError({ errorKey: "wallet_missing_params", info: { account } });
@@ -187,9 +187,7 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
 
         const { accountNumber, sequence = 0 } = account;
 
-        const msgs = [
-          buildAminoMsg({ chain: Chain.THORChain, assetValue, memo, from: address, ...rest }),
-        ];
+        const msgs = [buildAminoMsg({ assetValue, memo, sender: address, ...rest })];
 
         const chainId = ChainId.THORChain;
 
@@ -239,8 +237,9 @@ async function getToolbox<T extends (typeof WC_SUPPORTED_CHAINS)[number]>({
 
       return {
         ...toolbox,
-        transfer: (params: TransferParams) => thorchainTransfer(params),
-        deposit: (params: DepositParam) => thorchainTransfer(params),
+        transfer: (params: GenericTransferParams) => thorchainTransfer(params),
+        deposit: (params: ThorchainDepositParams) => thorchainTransfer(params),
+        getAccount,
       };
     }
     default:

package/dist/chunk-ha78se5g.js

@@ -1,4 +0,0 @@
-function a(e){let t=Object.keys(e)?.[0]||"";return e?.[t]?.supportedChains||[]}
-export{a as r};
-
-//# debugId=F206E598AB17CDC064756E2164756E21

package/dist/chunk-ha78se5g.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/helpers.ts"],
-  "sourcesContent": [
-    "import type { createWallet } from \"@swapkit/helpers\";\n\nexport function getWalletSupportedChains<\n  T extends ReturnType<typeof createWallet<any, any, any, any>>,\n>(wallet: T): T[keyof T][\"supportedChains\"] {\n  const walletName = Object.keys(wallet)?.[0] || \"\";\n  return wallet?.[walletName]?.supportedChains || [];\n}\n"
-  ],
-  "mappings": "AAEO,SAAS,CAEf,CAAC,EAA0C,CAC1C,IAAM,EAAa,OAAO,KAAK,CAAM,IAAI,IAAM,GAC/C,OAAO,IAAS,IAAa,iBAAmB,CAAC",
-  "debugId": "F206E598AB17CDC064756E2164756E21",
-  "names": []
-}

package/dist/chunk-yvbvzc0q.js

@@ -1,3 +0,0 @@
-var p={};a(p,{getWalletSupportedChains:()=>n});function n(e){let t=Object.keys(e)?.[0]||"";return e?.[t]?.supportedChains||[]}
-
-//# debugId=C48D3544860CE65864756E2164756E21

package/dist/chunk-yvbvzc0q.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/helpers.ts"],
-  "sourcesContent": [
-    "import type { createWallet } from \"@swapkit/helpers\";\n\nexport function getWalletSupportedChains<\n  T extends ReturnType<typeof createWallet<any, any, any, any>>,\n>(wallet: T): T[keyof T][\"supportedChains\"] {\n  const walletName = Object.keys(wallet)?.[0] || \"\";\n  return wallet?.[walletName]?.supportedChains || [];\n}\n"
-  ],
-  "mappings": "+CAEO,SAAS,CAEf,CAAC,EAA0C,CAC1C,IAAM,EAAa,OAAO,KAAK,CAAM,IAAI,IAAM,GAC/C,OAAO,IAAS,IAAa,iBAAmB,CAAC",
-  "debugId": "C48D3544860CE65864756E2164756E21",
-  "names": []
-}