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

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),
@@ -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

@@ -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,10 +66,9 @@ 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");
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
         const { success, payload } = await TrezorConnect.getAddress({
           path: derivationPathToString(path),
           coin,
@@ -86,44 +84,43 @@ 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();
 
       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),
         );
+        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:
@@ -228,7 +229,7 @@ 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) {
@@ -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: