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

package/src/exodus/index.ts

@@ -9,9 +9,7 @@ import {
   prepareNetworkSwitch,
   switchEVMWalletNetwork,
 } from "@swapkit/helpers";
-import type { NonETHToolbox } from "@swapkit/toolboxes/evm";
-import type { UTXOTransferParams } from "@swapkit/toolboxes/utxo";
-import type { Psbt } from "@swapkit/toolboxes/utxo";
+import type { Psbt } from "bitcoinjs-lib";
 import type { BrowserProvider, Eip1193Provider } from "ethers";
 import {
   AddressPurpose,
@@ -23,9 +21,9 @@ import {
   getAddress,
   signTransaction as satsSignTransaction,
 } from "sats-connect";
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 
-export const getWalletMethods = async ({
+async function getWalletMethods({
   walletProvider,
   provider,
   chain,
@@ -33,11 +31,11 @@ export const getWalletMethods = async ({
   walletProvider?: Eip1193Provider;
   provider: BrowserProvider | BitcoinProvider;
   chain: Chain;
-}) => {
+}) {
   switch (chain) {
     case Chain.Bitcoin: {
-      const { BTCToolbox, Psbt } = await import("@swapkit/toolboxes/utxo");
-      const toolbox = BTCToolbox();
+      const { Psbt } = await import("bitcoinjs-lib");
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
 
       let address = "";
 
@@ -60,6 +58,7 @@ export const getWalletMethods = async ({
         },
       };
 
+      // TODO: Towan - probably not needed ?
       await getAddress(getAddressOptions);
 
       async function signTransaction(psbt: Psbt) {
@@ -90,14 +89,13 @@ export const getWalletMethods = async ({
         return signedPsbt;
       }
 
-      const transfer = (transferParams: UTXOTransferParams) => {
-        return toolbox.transfer({
-          ...transferParams,
-          signTransaction,
-        });
+      const signer = {
+        signTransaction,
+        getAddress: () => Promise.resolve(address),
       };
+      const toolbox = await getUtxoToolbox(chain, { signer });
 
-      return { ...toolbox, transfer, address };
+      return { ...toolbox, address };
     }
     case Chain.Arbitrum:
     case Chain.Avalanche:
@@ -107,35 +105,32 @@ export const getWalletMethods = async ({
     case Chain.Optimism:
     case Chain.Polygon: {
       if (!walletProvider) throw new Error("Requested web3 wallet is not installed");
-      const { getProvider, getToolboxByChain } = await import("@swapkit/toolboxes/evm");
+      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
 
-      const jsonRpcProvider = getProvider(chain);
+      const jsonRpcProvider = await getProvider(chain);
       const browserProvider = provider as BrowserProvider;
 
       await browserProvider.send("eth_requestAccounts", []);
 
       const signer = await browserProvider.getSigner();
       const address = await signer.getAddress();
-      const toolbox = getToolboxByChain(chain)({ provider: jsonRpcProvider, signer });
+      const toolbox = await getEvmToolbox(chain, { provider: jsonRpcProvider, signer });
 
       try {
         if (chain !== Chain.Ethereum) {
-          const networkParams = (toolbox as NonETHToolbox).getNetworkParams();
+          const networkParams = toolbox.getNetworkParams();
           await switchEVMWalletNetwork(browserProvider, chain, networkParams);
         }
       } catch (_error) {
         throw new Error(`Failed to add/switch ${chain} network: ${chain}`);
       }
 
-      return {
-        address,
-        ...prepareNetworkSwitch<typeof toolbox>({ toolbox, chain, provider: browserProvider }),
-      };
+      return { ...prepareNetworkSwitch({ toolbox, chain, provider: browserProvider }), address };
     }
     default:
       throw new Error(`Unsupported chain: ${chain}`);
   }
-};
+}
 
 export const exodusWallet = createWallet({
   name: "connectExodusWallet",
@@ -162,9 +157,6 @@ export const exodusWallet = createWallet({
             walletProvider: providers.ethereum,
           });
 
-          const getBalance = async (potentialScamFilter = true) =>
-            walletMethods.getBalance(address, potentialScamFilter);
-
           const disconnect = () =>
             provider.send("wallet_revokePermissions", [{ eth_accounts: {} }]);
 
@@ -173,8 +165,6 @@ export const exodusWallet = createWallet({
             disconnect,
             chain,
             address,
-            getBalance,
-            balance: [],
             walletType: WalletOption.EXODUS,
           });
         }),

package/src/index.ts

@@ -1,37 +1,2 @@
-import { bitgetWallet } from "./bitget";
-import { coinbaseWallet } from "./coinbase";
-import { ctrlWallet } from "./ctrl";
-import { evmWallet } from "./evm-extensions";
-import { exodusWallet } from "./exodus";
-import { keepkeyWallet } from "./keepkey";
-import { keepkeyBexWallet } from "./keepkey-bex";
-import { keplrWallet } from "./keplr";
-import { keystoreWallet } from "./keystore";
-import { ledgerWallet } from "./ledger";
-import { okxWallet } from "./okx";
-import { phantomWallet } from "./phantom";
-import { polkadotWallet } from "./polkadotjs";
-import { radixWallet } from "./radix";
-import { talismanWallet } from "./talisman";
-import { trezorWallet } from "./trezor";
-import { walletconnectWallet } from "./walletconnect";
-
-export const wallets = {
-  ...bitgetWallet,
-  ...coinbaseWallet,
-  ...ctrlWallet,
-  ...evmWallet,
-  ...exodusWallet,
-  ...keepkeyWallet,
-  ...keepkeyBexWallet,
-  ...keplrWallet,
-  ...keystoreWallet,
-  ...ledgerWallet,
-  ...okxWallet,
-  ...phantomWallet,
-  ...polkadotWallet,
-  ...radixWallet,
-  ...talismanWallet,
-  ...trezorWallet,
-  ...walletconnectWallet,
-};
+export * from "./utils";
+export * from "./types";

package/src/keepkey/chains/cosmos.ts

@@ -7,7 +7,7 @@ import {
   SKConfig,
   derivationPathToString,
 } from "@swapkit/helpers";
-import type { TransferParams } from "@swapkit/toolboxes/cosmos";
+import type { GenericTransferParams } from "@swapkit/helpers";
 
 import { bip32ToAddressNList } from "../coins";
 
@@ -15,9 +15,12 @@ export const cosmosWalletMethods = async ({
   sdk,
   derivationPath,
 }: { sdk: KeepKeySdk; derivationPath?: DerivationPathArray }) => {
-  const { DEFAULT_COSMOS_FEE_MAINNET, GaiaToolbox, createStargateClient } = await import(
-    "@swapkit/toolboxes/cosmos"
-  );
+  const {
+    DEFAULT_COSMOS_FEE_MAINNET,
+    getCosmosToolbox,
+    getFeeRateFromThorswap,
+    createStargateClient,
+  } = await import("@swapkit/toolboxes/cosmos");
 
   try {
     const derivationPathString = derivationPath
@@ -28,16 +31,16 @@ export const cosmosWalletMethods = async ({
       address_n: bip32ToAddressNList(derivationPathString),
     })) as { address: string };
 
-    const toolbox = GaiaToolbox();
+    const toolbox = await getCosmosToolbox(Chain.Cosmos);
 
     if (DEFAULT_COSMOS_FEE_MAINNET.amount[0]) {
       DEFAULT_COSMOS_FEE_MAINNET.amount[0].amount = String(
-        await toolbox?.getFeeRateFromThorswap?.(ChainId.Cosmos, 500),
+        await getFeeRateFromThorswap(ChainId.Cosmos, 500),
       );
     }
 
     // TODO support other cosmos assets
-    const transfer = async ({ assetValue, recipient, memo }: TransferParams) => {
+    const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
       const amount = assetValue.getBaseValue("string");
       const accountInfo = await toolbox.getAccount(fromAddress);
 

package/src/keepkey/chains/mayachain.ts

@@ -5,17 +5,18 @@ import {
   ChainId,
   DerivationPath,
   type DerivationPathArray,
+  type GenericTransferParams,
   SKConfig,
   derivationPathToString,
 } from "@swapkit/helpers";
-import type { DepositParam, TransferParams } from "@swapkit/toolboxes/cosmos";
+import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
 
 import { bip32ToAddressNList } from "../coins";
 
 type SignTransactionParams = {
   assetValue: AssetValue;
   recipient?: string;
-  from: string;
+  sender: string;
   memo: string | undefined;
 };
 
@@ -26,9 +27,9 @@ export const mayachainWalletMethods = async ({
   sdk: KeepKeySdk;
   derivationPath?: DerivationPathArray;
 }) => {
-  const { createStargateClient, getToolboxByChain } = await import("@swapkit/toolboxes/cosmos");
+  const { createStargateClient, getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
 
-  const toolbox = getToolboxByChain(Chain.Maya)();
+  const toolbox = await getCosmosToolbox(Chain.Maya);
   const derivationPathString = derivationPath
     ? derivationPathToString(derivationPath)
     : `${DerivationPath.MAYA}/0`;
@@ -37,11 +38,16 @@ export const mayachainWalletMethods = async ({
     address_n: bip32ToAddressNList(derivationPathString),
   })) as { address: string };
 
-  const signTransaction = async ({ assetValue, recipient, from, memo }: SignTransactionParams) => {
+  const signTransaction = async ({
+    assetValue,
+    recipient,
+    sender,
+    memo,
+  }: SignTransactionParams) => {
     const { makeSignDoc } = await import("@cosmjs/amino");
     const { getDenomWithChain } = await import("@swapkit/toolboxes/cosmos");
 
-    const account = await toolbox.getAccount(from);
+    const account = await toolbox.getAccount(sender);
     if (!account) throw new Error("Account not found");
     const { accountNumber, sequence = 0 } = account;
     const amount = assetValue.getBaseValue("string");
@@ -54,7 +60,7 @@ export const mayachainWalletMethods = async ({
           type: "mayachain/MsgSend",
           value: {
             amount: [{ amount, denom: assetValue.symbol.toLowerCase() }],
-            from_address: from,
+            from_address: sender,
             to_address: recipient,
           },
         }
@@ -63,7 +69,7 @@ export const mayachainWalletMethods = async ({
           value: {
             coins: [{ amount, asset: getDenomWithChain(assetValue) }],
             memo,
-            signer: from,
+            signer: sender,
           },
         };
 
@@ -76,41 +82,35 @@ export const mayachainWalletMethods = async ({
       sequence,
     );
 
-    const signedTx = isTransfer
-      ? await sdk.mayachain.mayachainSignAminoTransfer({
-          // TODO can we ignore this ?
-          // @ts-expect-error readonly cant be assigned to writable
-          signDoc,
-          signerAddress: from,
-        })
-      : await sdk.mayachain.mayachainSignAminoDeposit({
-          // @ts-expect-error
-          signDoc,
-          signerAddress: from,
-        });
+    const sdkMethod = isTransfer
+      ? sdk.mayachain.mayachainSignAminoTransfer
+      : sdk.mayachain.mayachainSignAminoDeposit;
+
+    // @ts-expect-error TC
+    const signedTx = await sdkMethod({ signDoc, signerAddress: sender });
     const decodedBytes = atob(signedTx.serialized);
     return new Uint8Array(decodedBytes.length).map((_, i) => decodedBytes.charCodeAt(i));
   };
 
-  const transfer = async ({ assetValue, recipient, memo }: TransferParams) => {
+  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
     const stargateClient = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Maya]);
     const signedTransaction = await signTransaction({
       assetValue,
       recipient,
       memo,
-      from: fromAddress,
+      sender: fromAddress,
     });
     const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
 
     return transactionHash;
   };
 
-  const deposit = async ({ assetValue, memo }: DepositParam) => {
+  const deposit = async ({ assetValue, memo }: ThorchainDepositParams) => {
     const stargateClient = await createStargateClient(SKConfig.get("rpcUrls")[Chain.Maya]);
     const signedTransaction = await signTransaction({
       assetValue,
       memo,
-      from: fromAddress,
+      sender: fromAddress,
     });
     const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
 

package/src/keepkey/chains/thorchain.ts

@@ -9,17 +9,18 @@ import {
   ChainId,
   DerivationPath,
   type DerivationPathArray,
+  type GenericTransferParams,
   SKConfig,
   derivationPathToString,
 } from "@swapkit/helpers";
-import type { DepositParam, TransferParams } from "@swapkit/toolboxes/cosmos";
+import type { ThorchainDepositParams } from "@swapkit/toolboxes/cosmos";
 
 import { bip32ToAddressNList } from "../coins";
 
 type SignTransactionParams = {
   assetValue: AssetValue;
   recipient?: string;
-  from: string;
+  sender: string;
   memo: string | undefined;
 };
 
@@ -31,10 +32,10 @@ export const thorchainWalletMethods = async ({
   derivationPath?: DerivationPathArray;
 }) => {
   const { makeSignDoc } = await import("@cosmjs/amino");
-  const { buildAminoMsg, getDefaultChainFee, createStargateClient, ThorchainToolbox } =
+  const { buildAminoMsg, getDefaultChainFee, createStargateClient, getCosmosToolbox } =
     await import("@swapkit/toolboxes/cosmos");
 
-  const toolbox = ThorchainToolbox();
+  const toolbox = await getCosmosToolbox(Chain.THORChain);
   const derivationPathString = derivationPath
     ? derivationPathToString(derivationPath)
     : `${DerivationPath.THOR}/0`;
@@ -43,14 +44,19 @@ export const thorchainWalletMethods = async ({
     address_n: bip32ToAddressNList(derivationPathString),
   })) as { address: string };
 
-  const signTransaction = async ({ assetValue, recipient, from, memo }: SignTransactionParams) => {
-    const account = await toolbox.getAccount(from);
+  const signTransaction = async ({
+    assetValue,
+    recipient,
+    sender,
+    memo,
+  }: SignTransactionParams) => {
+    const account = await toolbox.getAccount(sender);
     if (!account) throw new Error("Account not found");
     const { accountNumber, sequence = 0 } = account;
 
     const isTransfer = recipient && recipient !== "";
 
-    const msg = buildAminoMsg({ chain: Chain.THORChain, from, recipient, assetValue, memo });
+    const msg = buildAminoMsg({ sender, recipient, assetValue, memo });
 
     const chainId = ChainId.THORChain;
 
@@ -66,35 +72,35 @@ export const thorchainWalletMethods = async ({
     const signedTx = isTransfer
       ? await sdk.thorchain.thorchainSignAminoTransfer({
           signDoc: signDoc as TypesThorchainSignDocTransfer,
-          signerAddress: from,
+          signerAddress: sender,
         })
       : await sdk.thorchain.thorchainSignAminoDeposit({
           signDoc: signDoc as TypesThorchainSignDocDeposit,
-          signerAddress: from,
+          signerAddress: sender,
         });
     const decodedBytes = atob(signedTx.serialized);
     return new Uint8Array(decodedBytes.length).map((_, i) => decodedBytes.charCodeAt(i));
   };
 
-  const transfer = async ({ assetValue, recipient, memo }: TransferParams) => {
+  const transfer = async ({ assetValue, recipient, memo }: GenericTransferParams) => {
     const stargateClient = await createStargateClient(SKConfig.get("rpcUrls")[Chain.THORChain]);
     const signedTransaction = await signTransaction({
       assetValue,
       recipient,
       memo,
-      from: fromAddress,
+      sender: fromAddress,
     });
     const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
 
     return transactionHash;
   };
 
-  const deposit = async ({ assetValue, memo }: DepositParam) => {
+  const deposit = async ({ assetValue, memo }: ThorchainDepositParams) => {
     const stargateClient = await createStargateClient(SKConfig.get("rpcUrls")[Chain.THORChain]);
     const signedTransaction = await signTransaction({
       assetValue,
       memo,
-      from: fromAddress,
+      sender: fromAddress,
     });
     const { transactionHash } = await stargateClient.broadcastTx(signedTransaction);
 

package/src/keepkey/chains/utxo.ts

@@ -1,30 +1,18 @@
+import type { KeepKeySdk } from "@keepkey/keepkey-sdk";
 import {
   Chain,
   DerivationPath,
   type DerivationPathArray,
   FeeOption,
+  type GenericTransferParams,
   type UTXOChain,
   derivationPathToString,
 } from "@swapkit/helpers";
-import type { BCHToolbox, Psbt, UTXOToolbox, UTXOTransferParams } from "@swapkit/toolboxes/utxo";
+import type { Psbt } from "bitcoinjs-lib";
 
+import type { UTXOToolboxes } from "@swapkit/toolboxes/utxo";
 import { ChainToKeepKeyName, bip32ToAddressNList } from "../coins";
 
-type KKUtxoWalletParams = {
-  sdk: any;
-  chain: UTXOChain;
-  derivationPath?: DerivationPathArray;
-};
-
-interface psbtTxOutput {
-  address: string;
-  script: Buffer;
-  value: number;
-  change?: boolean; // Optional, assuming it indicates if the output is a change
-}
-interface ExtendedPsbt extends Psbt {
-  txOutputs: psbtTxOutput[];
-}
 interface KeepKeyInputObject {
   addressNList: number[];
   scriptType: string;
@@ -38,21 +26,13 @@ export const utxoWalletMethods = async ({
   sdk,
   chain,
   derivationPath,
-}: KKUtxoWalletParams): Promise<
-  UTXOToolbox & {
-    address: string;
-    signTransaction: (
-      psbt: ExtendedPsbt,
-      inputs: KeepKeyInputObject[],
-      memo?: string,
-    ) => Promise<string>;
-    transfer: (params: UTXOTransferParams) => Promise<string>;
-  }
-> => {
-  const { getToolboxByChain } = await import("@swapkit/toolboxes/utxo");
-
-  const toolbox = getToolboxByChain(chain)();
-  const scriptType = [Chain.Bitcoin, Chain.Litecoin].includes(chain) ? "p2wpkh" : "p2pkh";
+}: { sdk: KeepKeySdk; chain: UTXOChain; derivationPath?: DerivationPathArray }) => {
+  const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+  // This might not work for BCH
+  const toolbox = await getUtxoToolbox(chain);
+  const scriptType = [Chain.Bitcoin, Chain.Litecoin].includes(chain)
+    ? ("p2wpkh" as const)
+    : ("p2pkh" as const);
 
   const derivationPathString = derivationPath
     ? derivationPathToString(derivationPath)
@@ -64,17 +44,21 @@ export const utxoWalletMethods = async ({
     address_n: bip32ToAddressNList(derivationPathString),
   };
 
-  const { address: walletAddress } = await sdk.address.utxoGetAddress(addressInfo);
+  const walletAddress: string = (await sdk.address.utxoGetAddress(addressInfo)).address;
 
   const signTransaction = async (psbt: Psbt, inputs: KeepKeyInputObject[], memo = "") => {
     const outputs = psbt.txOutputs
       .map((output) => {
-        const { value, address, change } = output as psbtTxOutput;
+        const { value, address, change } = output as {
+          address: string;
+          script: Buffer;
+          value: number;
+          change?: boolean;
+        };
 
         const outputAddress =
-          chain === Chain.BitcoinCash
-            ? (toolbox as ReturnType<typeof BCHToolbox>).stripToCashAddress(address)
-            : address;
+          // @ts-expect-error - stripToCashAddress is not defined in the UTXO toolbox just only on BCH
+          chain === Chain.BitcoinCash ? toolbox.stripToCashAddress(address) : address;
 
         if (change || address === walletAddress) {
           return {
@@ -85,6 +69,7 @@ export const utxoWalletMethods = async ({
             scriptType,
           };
         }
+
         if (outputAddress) {
           return { address: outputAddress, amount: value, addressType: "spend" };
         }
@@ -103,41 +88,44 @@ export const utxoWalletMethods = async ({
       coin: ChainToKeepKeyName[chain],
       inputs,
       outputs: removeNullAndEmptyObjectsFromArray(outputs),
-      version: 1,
-      locktime: 0,
       opReturnData: memo,
     });
-    return responseSign.serializedTx;
+
+    return responseSign.serializedTx?.toString();
   };
 
   const transfer = async ({
-    from,
     recipient,
     feeOptionKey,
     feeRate,
     memo,
     ...rest
-  }: UTXOTransferParams) => {
-    if (!from) throw new Error("From address must be provided");
+  }: GenericTransferParams) => {
+    if (!walletAddress) throw new Error("From address must be provided");
     if (!recipient) throw new Error("Recipient address must be provided");
 
-    const { psbt, inputs: rawInputs } = await toolbox.buildTx({
+    const createTxMethod =
+      chain === Chain.BitcoinCash
+        ? (toolbox as UTXOToolboxes["BCH"]).buildTx
+        : (toolbox as UTXOToolboxes["BTC"]).createTransaction;
+
+    const { psbt, inputs: rawInputs } = await createTxMethod({
       ...rest,
       memo,
       recipient,
       feeRate: feeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast],
-      sender: from,
-      fetchTxHex: chain === Chain.BitcoinCash,
+      sender: walletAddress,
+      fetchTxHex: true,
     });
 
     const inputs = rawInputs.map(({ value, index, hash, txHex }) => ({
       //@TODO don't hardcode master, lookup on blockbook what input this is for and what path that address is!
       addressNList: addressInfo.address_n,
-      scriptType,
       amount: value.toString(),
-      vout: index,
-      txid: hash,
       hex: txHex || "",
+      scriptType,
+      txid: hash,
+      vout: index,
     }));
 
     const txHex = await signTransaction(psbt, inputs, memo);

package/src/keepkey/index.ts

@@ -11,7 +11,7 @@ import {
 import { KeepKeySdk } from "@keepkey/keepkey-sdk";
 export type { PairingInfo } from "@keepkey/keepkey-sdk";
 
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 import { cosmosWalletMethods } from "./chains/cosmos";
 import { KeepKeySigner } from "./chains/evm";
 import { mayachainWalletMethods } from "./chains/mayachain";
@@ -60,13 +60,9 @@ export const keepkeyWallet = createWallet({
             derivationPath: derivationPathMap?.[chain] || NetworkDerivationPath[chain],
             sdk: keepKeySdk,
           });
+          const address = (await walletMethods.getAddress()) || "";
 
-          addChain({
-            ...walletMethods,
-            balance: [],
-            chain,
-            walletType: WalletOption.KEEPKEY,
-          });
+          addChain({ ...walletMethods, address, chain, walletType: WalletOption.KEEPKEY });
         }),
       );
       return true;
@@ -80,7 +76,7 @@ async function getWalletMethods({
   chain,
   derivationPath,
 }: { sdk: KeepKeySdk; chain: Chain; derivationPath?: DerivationPathArray }) {
-  const { getProvider, getToolboxByChain } = await import("@swapkit/toolboxes/evm");
+  const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
 
   switch (chain) {
     case Chain.BinanceSmartChain:
@@ -89,17 +85,11 @@ async function getWalletMethods({
     case Chain.Polygon:
     case Chain.Avalanche:
     case Chain.Ethereum: {
-      const provider = getProvider(chain);
-      const signer = new KeepKeySigner({
-        sdk,
-        chain,
-        derivationPath,
-        provider,
-      });
-      const address = await signer.getAddress();
-      const toolbox = getToolboxByChain(chain)({ provider, signer });
+      const provider = await getProvider(chain);
+      const signer = new KeepKeySigner({ sdk, chain, derivationPath, provider });
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
 
-      return { address, ...toolbox };
+      return toolbox;
     }
     case Chain.Cosmos: {
       return cosmosWalletMethods({ sdk, derivationPath });
@@ -115,11 +105,7 @@ async function getWalletMethods({
     case Chain.Dash:
     case Chain.Dogecoin:
     case Chain.Litecoin: {
-      return utxoWalletMethods({
-        sdk,
-        chain,
-        derivationPath,
-      });
+      return utxoWalletMethods({ sdk, chain, derivationPath });
     }
     default:
       throw new Error(`Chain not supported ${chain}`);