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

package/src/keepkey-bex/index.ts

@@ -1,17 +1,16 @@
 import {
   AssetValue,
   Chain,
+  ChainIdToChain,
   SwapKitError,
   WalletOption,
   createWallet,
   filterSupportedChains,
 } from "@swapkit/helpers";
-import type { NonETHToolbox } from "@swapkit/toolboxes/evm";
 import type { Eip1193Provider } from "ethers";
-import { getWalletSupportedChains } from "../helpers";
+import { getWalletSupportedChains } from "../utils";
 import {
   type WalletTxParams,
-  cosmosTransfer,
   getKEEPKEYAddress,
   getKEEPKEYMethods,
   getKEEPKEYProvider,
@@ -50,7 +49,7 @@ export const keepkeyBexWallet = createWallet({
           const address = await getKEEPKEYAddress(chain);
           const walletMethods = await getWalletMethods(chain);
 
-          addChain({ ...walletMethods, address, balance: [], chain, walletType });
+          addChain({ ...walletMethods, address, chain, walletType });
         }),
       );
 
@@ -64,15 +63,15 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
   switch (chain) {
     case Chain.Maya:
     case Chain.THORChain: {
-      const { getToolboxByChain, THORCHAIN_GAS_VALUE, MAYA_GAS_VALUE } = await import(
+      const { getCosmosToolbox, THORCHAIN_GAS_VALUE, MAYA_GAS_VALUE } = await import(
         "@swapkit/toolboxes/cosmos"
       );
 
       const gasLimit = chain === Chain.Maya ? MAYA_GAS_VALUE : THORCHAIN_GAS_VALUE;
-      const toolbox = getToolboxByChain(chain);
+      const toolbox = getCosmosToolbox(chain);
 
       return {
-        ...toolbox(),
+        ...toolbox,
         deposit: (tx: WalletTxParams) => walletTransfer({ ...tx, recipient: "" }, "deposit"),
         transfer: (tx: WalletTxParams) => walletTransfer({ ...tx, gasLimit }, "transfer"),
       };
@@ -80,10 +79,19 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
 
     case Chain.Cosmos:
     case Chain.Kujira: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/cosmos");
-      const toolbox = getToolboxByChain(chain)();
+      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
 
-      return { ...toolbox, transfer: cosmosTransfer(chain) };
+      // @ts-expect-error assumed available connection
+      const signer = window.keepkey?.cosmos?.getOfflineSignerOnlyAmino(ChainIdToChain[chain]);
+      if (!signer) throw new Error("Could not load signer");
+      const toolbox = getCosmosToolbox(chain, { signer });
+
+      const accounts = await signer.getAccounts();
+      if (!accounts?.[0]?.address) throw new Error("No accounts found");
+
+      const [{ address }] = accounts;
+
+      return { ...toolbox, address };
     }
 
     case Chain.Dash:
@@ -91,8 +99,8 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
     case Chain.BitcoinCash:
     case Chain.Dogecoin:
     case Chain.Litecoin: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/utxo");
-      const toolbox = getToolboxByChain(chain)();
+      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
+      const toolbox = await getUtxoToolbox(chain);
 
       const getBalance = async () => {
         try {
@@ -120,7 +128,7 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
     case Chain.Polygon:
     case Chain.Avalanche: {
       const { prepareNetworkSwitch, switchEVMWalletNetwork } = await import("@swapkit/helpers");
-      const { getToolboxByChain, getBalance, getProvider } = await import("@swapkit/toolboxes/evm");
+      const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
       const { BrowserProvider } = await import("ethers");
       const ethereumWindowProvider = getKEEPKEYProvider(chain) as Eip1193Provider;
 
@@ -130,12 +138,12 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
 
       const provider = new BrowserProvider(ethereumWindowProvider, "any");
       const signer = await provider.getSigner();
-      const toolbox = getToolboxByChain(chain)({ provider, signer });
-      const keepkeyMethods = getKEEPKEYMethods(provider);
+      const toolbox = await getEvmToolbox(chain, { provider, signer });
+      const keepkeyMethods = getKEEPKEYMethods(provider, chain);
 
       try {
         if (chain !== Chain.Ethereum) {
-          const networkParams = (toolbox as NonETHToolbox).getNetworkParams();
+          const networkParams = toolbox.getNetworkParams();
           await switchEVMWalletNetwork(provider, chain, networkParams);
         }
       } catch (_error) {
@@ -148,13 +156,7 @@ async function getWalletMethods(chain: (typeof KEEPKEY_BEX_SUPPORTED_CHAINS)[num
       return prepareNetworkSwitch({
         provider,
         chain,
-        toolbox: {
-          ...toolbox,
-          ...keepkeyMethods,
-          // Overwrite getBalance due to race conditions
-          getBalance: (address: string, potentialScamFilter?: boolean) =>
-            getBalance({ chain, provider: getProvider(chain), address, potentialScamFilter }),
-        },
+        toolbox: { ...toolbox, ...keepkeyMethods },
       });
     }
 

package/src/keepkey-bex/walletHelpers.ts

@@ -1,17 +1,13 @@
 import {
   type AssetValue,
   Chain,
-  ChainToChainId,
-  type CosmosChain,
   type EVMChain,
   EVMChains,
   type FeeOption,
-  SKConfig,
   SwapKitError,
   WalletOption,
 } from "@swapkit/helpers";
 import { erc20ABI } from "@swapkit/helpers/contracts";
-import type { TransferParams } from "@swapkit/toolboxes/cosmos";
 import type { ApproveParams, CallParams, EVMTxParams } from "@swapkit/toolboxes/evm";
 import type { BrowserProvider, Eip1193Provider } from "ethers";
 
@@ -188,33 +184,7 @@ export async function walletTransfer(
   return transaction({ method, params, chain: assetValue.chain });
 }
 
-export function cosmosTransfer(chain: CosmosChain) {
-  const chainId = ChainToChainId[chain];
-  return async ({ from, recipient, assetValue }: TransferParams) => {
-    const { getMsgSendDenom, createSigningStargateClient } = await import(
-      "@swapkit/toolboxes/cosmos"
-    );
-    // @ts-expect-error assumed available connection
-    const offlineSigner = window.keepkey?.cosmos?.getOfflineSignerOnlyAmino(chainId);
-    const cosmJS = await createSigningStargateClient(SKConfig.get("rpcUrls")[chain], offlineSigner);
-
-    const coins = [
-      {
-        denom: getMsgSendDenom(assetValue.symbol).toLowerCase(),
-        amount: assetValue.getBaseValue("string"),
-      },
-    ];
-
-    try {
-      const { transactionHash } = await cosmJS.sendTokens(from, recipient, coins, 2);
-      return transactionHash;
-    } catch (error) {
-      throw new SwapKitError("core_transaction_failed", { error });
-    }
-  };
-}
-
-export function getKEEPKEYMethods(provider: BrowserProvider) {
+export function getKEEPKEYMethods(provider: BrowserProvider, chain: EVMChain) {
   return {
     call: async <T>({
       contractAddress,
@@ -226,13 +196,14 @@ export function getKEEPKEYMethods(provider: BrowserProvider) {
       if (!contractAddress) {
         throw new SwapKitError("wallet_keepkey_contract_address_not_provided");
       }
-      const { createContract, createContractTxObject, isStateChangingCall, toHexString } =
+      const { createContract, getCreateContractTxObject, isStateChangingCall, toHexString } =
         await import("@swapkit/toolboxes/evm");
 
-      const isStateChanging = isStateChangingCall(abi, funcName);
+      const isStateChanging = isStateChangingCall({ abi, funcName });
 
       if (isStateChanging) {
-        const { value, from, to, data } = await createContractTxObject(provider, {
+        const createTx = getCreateContractTxObject({ provider, chain });
+        const { value, from, to, data } = await createTx({
           contractAddress,
           abi,
           funcName,
@@ -251,11 +222,12 @@ export function getKEEPKEYMethods(provider: BrowserProvider) {
       return typeof result?.hash === "string" ? result?.hash : result;
     },
     approve: async ({ assetAddress, spenderAddress, amount, from }: ApproveParams) => {
-      const { MAX_APPROVAL, createContractTxObject, toHexString } = await import(
+      const { MAX_APPROVAL, getCreateContractTxObject, toHexString } = await import(
         "@swapkit/toolboxes/evm"
       );
 
-      const { value, to, data } = await createContractTxObject(provider, {
+      const createTx = getCreateContractTxObject({ provider, chain });
+      const { value, to, data } = await createTx({
         contractAddress: assetAddress,
         abi: erc20ABI,
         funcName: "approve",

package/src/keplr/index.ts

@@ -1,6 +1,4 @@
-import type { Keplr } from "@keplr-wallet/types";
 import {
-  type AssetValue,
   Chain,
   ChainId,
   ChainToChainId,
@@ -8,16 +6,8 @@ import {
   createWallet,
   filterSupportedChains,
 } from "@swapkit/helpers";
-import type { CosmosToolboxType } from "@swapkit/toolboxes/cosmos";
 import { chainRegistry } from "./chainRegistry";
 
-declare global {
-  interface Window {
-    keplr: Keplr;
-    leap: Keplr;
-  }
-}
-
 const keplrSupportedChainIds = [ChainId.Cosmos, ChainId.Kujira, ChainId.THORChain] as const;
 
 export const keplrWallet = createWallet({
@@ -33,7 +23,6 @@ export const keplrWallet = createWallet({
       const keplrClient = window[extensionKey];
 
       await Promise.all(
-        // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: refactor/split
         filteredChains.map(async (chain) => {
           const chainId = ChainToChainId[chain] as (typeof keplrSupportedChainIds)[number];
 
@@ -45,54 +34,18 @@ export const keplrWallet = createWallet({
           }
 
           keplrClient?.enable(chainId);
-          const offlineSigner = keplrClient?.getOfflineSignerOnlyAmino(chainId);
-          if (!offlineSigner) throw new Error("Could not load offlineSigner");
+          const signer = keplrClient?.getOfflineSignerOnlyAmino(chainId);
+          if (!signer) throw new Error("Could not load signer");
 
-          const { getToolboxByChain } = await import("@swapkit/toolboxes/cosmos");
+          const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
 
-          const accounts = await offlineSigner.getAccounts();
+          const accounts = await signer.getAccounts();
           if (!accounts?.[0]?.address) throw new Error("No accounts found");
 
           const [{ address }] = accounts;
-          const toolbox = getToolboxByChain(chain)();
-
-          const transfer = (params: {
-            from?: string;
-            recipient: string;
-            assetValue: AssetValue;
-            memo?: string;
-          }) =>
-            toolbox.transfer({
-              ...params,
-              signer: offlineSigner,
-              fee: 2,
-              from: params.from || address,
-            });
-
-          const deposit =
-            chain === Chain.THORChain
-              ? (params: {
-                  from?: string;
-                  assetValue: AssetValue;
-                  memo?: string;
-                }) =>
-                  (toolbox as ReturnType<CosmosToolboxType["THOR"]>).deposit({
-                    ...params,
-                    signer: offlineSigner,
-                    from: params.from || address,
-                    memo: params.memo || "",
-                  })
-              : undefined;
+          const toolbox = getCosmosToolbox(chain, { signer });
 
-          addChain({
-            ...toolbox,
-            deposit,
-            chain,
-            transfer,
-            address,
-            balance: [],
-            walletType,
-          });
+          addChain({ ...toolbox, chain, address, walletType });
         }),
       );
 

package/src/keystore/helpers.ts

@@ -1,7 +1,5 @@
-import crypto from "crypto";
 import { generateMnemonic, validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english";
-import { blake2bFinal, blake2bInit, blake2bUpdate } from "blakejs";
 
 export type Keystore = {
   version: number;
@@ -16,10 +14,8 @@ export type Keystore = {
   };
 };
 
-/**
- * taken from `foundry-primitives` and modified
- */
-const blake256 = (initData: Buffer | string): string => {
+async function blake256(initData: Buffer | string) {
+  const { blake2bFinal, blake2bInit, blake2bUpdate } = await import("blakejs");
   let data = initData;
 
   if (!(data instanceof Buffer)) {
@@ -33,43 +29,24 @@ const blake256 = (initData: Buffer | string): string => {
   return Array.from(blake2bFinal(context))
     .map((byte) => (byte < 0x10 ? `0${byte.toString(16)}` : byte.toString(16)))
     .join("");
-};
+}
 
-const pbkdf2Async = (
-  passphrase: string | Buffer,
-  salt: string | Buffer,
-  iterations: number,
-  keylen: number,
-  digest: string,
-) =>
-  new Promise<Buffer>((resolve, reject) => {
-    crypto.pbkdf2(passphrase, salt, iterations, keylen, digest, (error, drived) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(drived);
-      }
-    });
-  });
+export async function encryptToKeyStore(phrase: string, password: string) {
+  const { pbkdf2Sync, randomBytes, createCipheriv } = await import("node:crypto");
 
-export const encryptToKeyStore = async (phrase: string, password: string) => {
-  const salt = crypto.randomBytes(32);
-  const iv = crypto.randomBytes(16);
-  const kdfParams = { c: 262144, prf: "hmac-sha256", dklen: 32, salt: salt.toString("hex") };
   const cipher = "aes-128-ctr";
+  const iv = randomBytes(16);
+  const salt = randomBytes(32);
+  const kdfParams = { c: 262144, prf: "hmac-sha256", dklen: 32, salt: salt.toString("hex") };
 
-  const derivedKey = await pbkdf2Async(
-    Buffer.from(password),
-    salt,
-    kdfParams.c,
-    kdfParams.dklen,
-    "sha256",
-  );
-  const cipherIV = crypto.createCipheriv(cipher, derivedKey.subarray(0, 16), iv);
+  const derivedKey = pbkdf2Sync(password, salt, kdfParams.c, kdfParams.dklen, "sha256");
+  const cipherIV = createCipheriv(cipher, derivedKey.subarray(0, 16), iv);
   const ciphertext = Buffer.concat([
     cipherIV.update(Buffer.from(phrase, "utf8")),
     cipherIV.final(),
   ]);
+  const initData = Buffer.concat([derivedKey.subarray(16, 32), Buffer.from(ciphertext)]);
+  const mac = await blake256(initData);
 
   return {
     meta: "xchain-keystore",
@@ -80,36 +57,38 @@ export const encryptToKeyStore = async (phrase: string, password: string) => {
       ciphertext: ciphertext.toString("hex"),
       kdf: "pbkdf2",
       kdfparams: kdfParams,
-      mac: blake256(Buffer.concat([derivedKey.subarray(16, 32), Buffer.from(ciphertext)])),
+      mac,
     },
   };
-};
+}
 
-export const generatePhrase = (size: 12 | 24 = 12) => {
+export function generatePhrase(size: 12 | 24 = 12) {
   return generateMnemonic(wordlist, size === 12 ? 128 : 256);
-};
+}
 
-export const validatePhrase = (phrase: string) => {
+export function validatePhrase(phrase: string) {
   return validateMnemonic(phrase, wordlist);
-};
+}
+
+export async function decryptFromKeystore(keystore: Keystore, password: string) {
+  const { createDecipheriv, pbkdf2Sync } = await import("node:crypto");
+  const { SwapKitError } = await import("@swapkit/helpers");
 
-export const decryptFromKeystore = async (keystore: Keystore, password: string) => {
   switch (keystore.version) {
     case 1: {
-      const kdfparams = keystore.crypto.kdfparams;
-      const derivedKey = await pbkdf2Async(
-        Buffer.from(password),
-        Buffer.from(kdfparams.salt, "hex"),
-        kdfparams.c,
-        kdfparams.dklen,
-        "sha256",
-      );
+      const kdfParams = keystore.crypto.kdfparams;
+      const salt = Buffer.from(kdfParams.salt, "hex");
+      const derivedKey = pbkdf2Sync(password, salt, kdfParams.c, kdfParams.dklen, "sha256");
 
       const ciphertext = Buffer.from(keystore.crypto.ciphertext, "hex");
-      const mac = blake256(Buffer.concat([derivedKey.subarray(16, 32), ciphertext]));
+      const initData = Buffer.concat([derivedKey.subarray(16, 32), ciphertext]);
+      const mac = await blake256(initData);
 
-      if (mac !== keystore.crypto.mac) throw new Error("Invalid password");
-      const decipher = crypto.createDecipheriv(
+      if (mac !== keystore.crypto.mac) {
+        throw new SwapKitError("wallet_keystore_invalid_password");
+      }
+
+      const decipher = createDecipheriv(
         keystore.crypto.cipher,
         derivedKey.subarray(0, 16),
         Buffer.from(keystore.crypto.cipherparams.iv, "hex"),
@@ -120,6 +99,6 @@ export const decryptFromKeystore = async (keystore: Keystore, password: string)
     }
 
     default:
-      throw new Error("Unsupported keystore version");
+      throw new SwapKitError("wallet_keystore_unsupported_version");
   }
-};
+}

package/src/keystore/index.ts

@@ -1,176 +1,16 @@
 import {
-  type AssetValue,
   Chain,
   CosmosChains,
   type DerivationPathArray,
   EVMChains,
   NetworkDerivationPath,
-  SKConfig,
   UTXOChains,
   WalletOption,
-  type WalletTxParams,
   createWallet,
-  derivationPathToString,
   filterSupportedChains,
-  updatedLastIndex,
+  updateDerivationPath,
 } from "@swapkit/helpers";
-import type { DepositParam, TransferParams } from "@swapkit/toolboxes/cosmos";
-import type {
-  Psbt,
-  TransactionType,
-  UTXOTransferParams,
-  UTXOWalletTransferParams,
-} from "@swapkit/toolboxes/utxo";
-import { getWalletSupportedChains } from "../helpers";
-
-type Params = {
-  chain: Chain;
-  phrase: string;
-  derivationPath: string;
-};
-
-const getWalletMethods = async ({ chain, phrase, derivationPath }: Params) => {
-  const rpcUrl = SKConfig.get("rpcUrls")[chain];
-
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Optimism:
-    case Chain.Polygon: {
-      const { getProvider, getToolboxByChain } = await import("@swapkit/toolboxes/evm");
-      const { HDNodeWallet } = await import("ethers");
-
-      const provider = getProvider(chain, rpcUrl);
-      const wallet = HDNodeWallet.fromPhrase(phrase).connect(provider);
-      const toolbox = getToolboxByChain(chain)({ provider, signer: wallet });
-
-      return { address: wallet.address, walletMethods: toolbox };
-    }
-
-    case Chain.BitcoinCash: {
-      const { BCHToolbox } = await import("@swapkit/toolboxes/utxo");
-      const toolbox = BCHToolbox();
-      const keys = await toolbox.createKeysForPath({ phrase, derivationPath });
-      const address = toolbox.getAddressFromKeys(keys);
-
-      async function signTransaction({
-        builder,
-        utxos,
-      }: Awaited<ReturnType<typeof toolbox.buildBCHTx>>) {
-        utxos.forEach((utxo, index) => {
-          builder.sign(index, keys, undefined, 0x41, utxo.witnessUtxo?.value);
-        });
-
-        return builder.build();
-      }
-
-      const walletMethods = {
-        ...toolbox,
-        transfer: (
-          params: UTXOWalletTransferParams<
-            Awaited<ReturnType<typeof toolbox.buildBCHTx>>,
-            TransactionType
-          >,
-        ) => toolbox.transfer({ ...params, from: address, signTransaction }),
-      };
-
-      return { address, walletMethods };
-    }
-
-    case Chain.Bitcoin:
-    case Chain.Dash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/utxo");
-
-      const toolbox = getToolboxByChain(chain)();
-
-      const keys = await toolbox.createKeysForPath({ phrase, derivationPath });
-      const address = toolbox.getAddressFromKeys(keys);
-
-      return {
-        address,
-        walletMethods: {
-          ...toolbox,
-          transfer: (params: UTXOTransferParams) =>
-            toolbox.transfer({
-              ...params,
-              from: address,
-              signTransaction: async (psbt: Psbt) => psbt.signAllInputs(keys),
-            }),
-        },
-      };
-    }
-
-    case Chain.Cosmos:
-    case Chain.Kujira: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/cosmos");
-      const toolbox = getToolboxByChain(chain)();
-      const address = await toolbox.getAddressFromMnemonic(phrase);
-      const signer = await toolbox.getSigner(phrase);
-
-      const transfer = (params: TransferParams) => toolbox.transfer({ ...params, signer });
-
-      return { address, walletMethods: { ...toolbox, transfer } };
-    }
-
-    case Chain.Maya:
-    case Chain.THORChain: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/cosmos");
-
-      const toolbox = getToolboxByChain(chain)();
-      const signer = await toolbox.getSigner(phrase);
-      const address = await toolbox.getAddressFromMnemonic(phrase);
-
-      return {
-        address,
-        walletMethods: {
-          ...toolbox,
-          deposit: (params: DepositParam) => toolbox.deposit({ ...params, from: address, signer }),
-          transfer: (params: TransferParams) =>
-            toolbox.transfer({ ...params, from: address, signer }),
-          signMessage: async (message: string) => {
-            const privateKey = await toolbox.createPrivateKeyFromPhrase(phrase);
-            return toolbox.signWithPrivateKey({ privateKey, message });
-          },
-        },
-      };
-    }
-
-    case Chain.Polkadot:
-    case Chain.Chainflip: {
-      const { Network, getToolboxByChain, createKeyring } = await import(
-        "@swapkit/toolboxes/substrate"
-      );
-
-      const signer = await createKeyring(phrase, Network[chain].prefix);
-      const toolbox = await getToolboxByChain(chain, { signer });
-
-      return { address: signer.address, walletMethods: toolbox };
-    }
-
-    case Chain.Solana: {
-      const { SOLToolbox } = await import("@swapkit/toolboxes/solana");
-      const toolbox = SOLToolbox();
-      const keypair = await toolbox.createKeysForPath({ phrase, derivationPath });
-
-      return {
-        address: toolbox.getAddressFromKeys(keypair),
-        walletMethods: {
-          ...toolbox,
-          transfer: (params: WalletTxParams & { assetValue: AssetValue }) =>
-            toolbox.transfer({ ...params, fromKeypair: keypair }),
-        },
-      };
-    }
-
-    default:
-      throw new Error(`Unsupported chain ${chain}`);
-  }
-};
+import { getWalletSupportedChains } from "../utils";
 
 export const keystoreWallet = createWallet({
   name: "connectKeystore",
@@ -181,6 +21,7 @@ export const keystoreWallet = createWallet({
     ...CosmosChains,
     Chain.Polkadot,
     Chain.Chainflip,
+    Chain.Ripple,
     Chain.Solana,
   ],
   connect: ({ addChain, supportedChains, walletType }) =>
@@ -201,32 +42,23 @@ export const keystoreWallet = createWallet({
               ? derivationPathMapOrIndex[chain]
               : undefined;
 
-          const [first, second, third, fourth, fifth] = NetworkDerivationPath[chain];
+          const derivationArrayToUpdate = NetworkDerivationPath[chain].slice(
+            0,
+            chain === Chain.Solana ? 4 : 5,
+          ) as DerivationPathArray;
 
-          const derivationPathArray: DerivationPathArray =
+          const derivationPath: DerivationPathArray =
             derivationPathFromMap ||
-            updatedLastIndex(
-              chain === Chain.Solana
-                ? [first, second, third, fourth]
-                : [first, second, third, fourth, fifth],
-              derivationPathIndex,
-            );
+            updateDerivationPath(derivationArrayToUpdate, { index: derivationPathIndex });
+
+          const { getToolbox } = await import("@swapkit/toolboxes");
 
-          const derivationPath = derivationPathToString(derivationPathArray);
+          const toolbox = await getToolbox(chain, { phrase, derivationPath });
+          const address = (await toolbox.getAddress()) || "";
 
-          const { address, walletMethods } = await getWalletMethods({
-            chain,
-            derivationPath,
-            phrase,
-          });
+          const wallet = { ...toolbox, address };
 
-          addChain({
-            ...walletMethods,
-            address,
-            balance: [],
-            chain,
-            walletType: WalletOption.KEYSTORE,
-          });
+          addChain({ ...wallet, chain, walletType: WalletOption.KEYSTORE });
         }),
       );