@swapkit/wallets 4.0.0-beta.54 → 4.0.0-beta.56

package/src/talisman/index.ts

@@ -1,130 +0,0 @@
-import {
-  Chain,
-  type EVMChain,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-  prepareNetworkSwitch,
-  switchEVMWalletNetwork,
-} from "@swapkit/helpers";
-import type { Eip1193Provider } from "ethers";
-import { getWalletSupportedChains } from "../utils";
-
-export const talismanWallet = createWallet({
-  name: "connectTalisman",
-  walletType: WalletOption.TALISMAN,
-  supportedChains: [
-    Chain.Ethereum,
-    Chain.Arbitrum,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.Polygon,
-    Chain.BinanceSmartChain,
-    Chain.Optimism,
-    Chain.Polkadot,
-    Chain.Chainflip,
-  ],
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectTalisman(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const walletMethods = await getWalletMethods(chain);
-
-          addChain({ ...walletMethods, chain, walletType });
-        }),
-      );
-
-      return true;
-    },
-});
-
-export const TALISMAN_SUPPORTED_CHAINS = getWalletSupportedChains(talismanWallet);
-
-async function getWeb3WalletMethods({
-  walletProvider,
-  chain,
-}: { walletProvider: Eip1193Provider | undefined; chain: EVMChain }) {
-  const { getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-  const { BrowserProvider } = await import("ethers");
-
-  if (!walletProvider) {
-    throw new SwapKitError({
-      errorKey: "wallet_provider_not_found",
-      info: { wallet: WalletOption.TALISMAN, chain },
-    });
-  }
-
-  const provider = new BrowserProvider(walletProvider, "any");
-  const signer = await provider.getSigner();
-  const toolbox = await getEvmToolbox(chain, { provider, signer });
-
-  try {
-    if (chain !== Chain.Ethereum) {
-      await switchEVMWalletNetwork(provider, chain, toolbox.getNetworkParams());
-    }
-  } catch (_error) {
-    throw new SwapKitError({
-      errorKey: "wallet_failed_to_add_or_switch_network",
-      info: { wallet: WalletOption.TALISMAN, chain },
-    });
-  }
-
-  return prepareNetworkSwitch({ toolbox, chain, provider });
-}
-
-async function getWalletMethods(chain: Chain) {
-  switch (chain) {
-    case Chain.Ethereum:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.Polygon:
-    case Chain.Avalanche:
-    case Chain.BinanceSmartChain:
-    case Chain.Base: {
-      if (!(window.talismanEth && "send" in window.talismanEth)) {
-        throw new SwapKitError({ errorKey: "wallet_talisman_not_found", info: { chain } });
-      }
-
-      const evmWallet = await getWeb3WalletMethods({ chain, walletProvider: window.talismanEth });
-      const address: string = (await window.talismanEth.send("eth_requestAccounts", []))[0];
-
-      return { ...evmWallet, address };
-    }
-
-    case Chain.Polkadot:
-    case Chain.Chainflip: {
-      const { getSubstrateToolbox, SubstrateNetwork } = await import(
-        "@swapkit/toolboxes/substrate"
-      );
-
-      const injectedExtension = window?.injectedWeb3?.talisman;
-      const rawExtension = await injectedExtension?.enable?.("talisman");
-
-      if (!rawExtension) {
-        throw new SwapKitError({ errorKey: "wallet_talisman_not_enabled", info: { chain } });
-      }
-
-      const toolbox = await getSubstrateToolbox(chain, { signer: rawExtension.signer });
-      const accounts = await rawExtension.accounts.get();
-
-      if (!accounts[0]?.address) {
-        throw new SwapKitError({
-          errorKey: "wallet_missing_params",
-          info: { wallet: WalletOption.TALISMAN, accounts, address: accounts[0]?.address },
-        });
-      }
-      const address = toolbox.convertAddress(accounts[0].address, SubstrateNetwork[chain].prefix);
-
-      return { ...toolbox, address };
-    }
-
-    default:
-      throw new SwapKitError({
-        errorKey: "wallet_chain_not_supported",
-        info: { chain, wallet: WalletOption.TALISMAN },
-      });
-  }
-}

package/src/trezor/evmSigner.ts

@@ -1,197 +0,0 @@
-import {
-  type Chain,
-  ChainToChainId,
-  type DerivationPathArray,
-  SwapKitError,
-  SwapKitNumber,
-  WalletOption,
-  derivationPathToString,
-} from "@swapkit/helpers";
-import type { JsonRpcProvider, Provider, TransactionRequest } from "ethers";
-
-type TrezorEVMSignerParams = {
-  chain: Chain;
-  derivationPath: DerivationPathArray;
-  provider: Provider | JsonRpcProvider;
-};
-
-export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEVMSignerParams) {
-  const { AbstractSigner, Signature } = await import("ethers");
-
-  class TrezorSigner extends AbstractSigner {
-    address: string;
-    chain: Chain;
-    derivationPath: DerivationPathArray;
-    readonly provider: Provider | JsonRpcProvider;
-
-    constructor({ chain, derivationPath, provider }: TrezorEVMSignerParams) {
-      super(provider);
-
-      this.address = "";
-      this.chain = chain;
-      this.derivationPath = derivationPath;
-      this.provider = provider;
-    }
-
-    getAddress = async () => {
-      if (!this.address) {
-        const TrezorConnect = (await import("@trezor/connect-web")).default;
-
-        const result = await TrezorConnect.ethereumGetAddress({
-          path: derivationPathToString(this.derivationPath),
-          showOnTrezor: true,
-        });
-
-        if (!result.success) {
-          throw new SwapKitError({
-            errorKey: "wallet_trezor_failed_to_get_address",
-            info: { ...result, chain: this.chain, derivationPath: this.derivationPath },
-          });
-        }
-
-        this.address = result.payload.address;
-      }
-
-      return this.address;
-    };
-
-    signMessage = async (message: string) => {
-      const TrezorConnect = (await import("@trezor/connect-web")).default;
-
-      const result = await TrezorConnect.ethereumSignMessage({
-        path: derivationPathToString(this.derivationPath),
-        message,
-      });
-
-      if (!result.success) {
-        throw new SwapKitError({
-          errorKey: "wallet_trezor_failed_to_sign_transaction",
-          info: { ...result, message, chain: this.chain, derivationPath: this.derivationPath },
-        });
-      }
-
-      return result.payload.signature;
-    };
-
-    signTypedData(): Promise<string> {
-      throw new SwapKitError("wallet_trezor_method_not_supported", { method: "signTypedData" });
-    }
-
-    signTransaction = async ({
-      to,
-      gasLimit,
-      value,
-      data,
-      nonce,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      gasPrice,
-      // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: any: refactor
-    }: TransactionRequest) => {
-      if (!to) throw new SwapKitError({ errorKey: "wallet_missing_params", info: { to } });
-      if (!gasLimit)
-        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasLimit } });
-
-      const isEIP1559 = maxFeePerGas && maxPriorityFeePerGas;
-
-      if (isEIP1559 && !maxFeePerGas) {
-        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxFeePerGas } });
-      }
-      if (isEIP1559 && !maxPriorityFeePerGas) {
-        throw new SwapKitError({
-          errorKey: "wallet_missing_params",
-          info: { maxPriorityFeePerGas },
-        });
-      }
-      if (!(isEIP1559 || gasPrice)) {
-        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasPrice } });
-      }
-
-      const TrezorConnect = (await import("@trezor/connect-web")).default;
-      const { toHexString } = await import("@swapkit/toolboxes/evm");
-      const { Transaction } = await import("ethers");
-
-      const additionalFields = isEIP1559
-        ? {
-            maxFeePerGas: toHexString(BigInt(maxFeePerGas?.toString() || 0)),
-            maxPriorityFeePerGas: toHexString(BigInt(maxPriorityFeePerGas?.toString() || 0)),
-          }
-        : (gasPrice && { gasPrice: toHexString(BigInt(gasPrice?.toString() || 0)) }) || {
-            gasPrice: "0x0",
-          };
-
-      const hexifiedNonce = toHexString(
-        BigInt(
-          nonce || (await this.provider.getTransactionCount(await this.getAddress(), "pending")),
-        ),
-      );
-
-      const formattedTx = {
-        chainId: Number.parseInt(ChainToChainId[this.chain]),
-        to: to.toString(),
-        value: toHexString(BigInt(value?.toString() || 0)),
-        gasLimit: toHexString(BigInt(gasLimit?.toString() || 0)),
-        nonce: hexifiedNonce,
-        data: data?.toString() || "0x",
-        ...additionalFields,
-      };
-
-      const { success, payload } = await TrezorConnect.ethereumSignTransaction({
-        path: derivationPathToString(this.derivationPath),
-        transaction: formattedTx,
-      });
-
-      if (!success) {
-        throw new SwapKitError({
-          errorKey: "wallet_trezor_failed_to_sign_transaction",
-          info: { ...payload, chain: this.chain, derivationPath: this.derivationPath },
-        });
-      }
-
-      const { r, s, v } = payload;
-
-      const signature = Signature.from({
-        r,
-        s,
-        v: new SwapKitNumber(BigInt(v)).getBaseValue("number"),
-      });
-
-      const serializedTx = Transaction.from({
-        ...formattedTx,
-        nonce: Number.parseInt(formattedTx.nonce, 16),
-        type: isEIP1559 ? 2 : 0,
-        signature,
-      }).serialized;
-
-      if (!serializedTx) {
-        throw new SwapKitError({
-          errorKey: "wallet_trezor_failed_to_sign_transaction",
-          info: { chain: this.chain, derivationPath: this.derivationPath },
-        });
-      }
-
-      return serializedTx;
-    };
-
-    connect = (provider: Provider | null) => {
-      if (!provider) {
-        throw new SwapKitError({
-          errorKey: "wallet_provider_not_found",
-          info: {
-            wallet: WalletOption.TREZOR,
-            chain: this.chain,
-            derivationPath: this.derivationPath,
-          },
-        });
-      }
-
-      return new TrezorSigner({
-        chain: this.chain,
-        derivationPath: this.derivationPath,
-        provider,
-      });
-    };
-  }
-
-  return new TrezorSigner({ chain, derivationPath, provider });
-}

package/src/trezor/index.ts

@@ -1,260 +0,0 @@
-import {
-  Chain,
-  type DerivationPathArray,
-  FeeOption,
-  type GenericTransferParams,
-  SKConfig,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  derivationPathToString,
-  filterSupportedChains,
-} from "@swapkit/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]) {
-    case 84:
-      return { input: "SPENDWITNESS", output: "PAYTOWITNESS" } as const;
-    case 49:
-      return { input: "SPENDP2SHWITNESS", output: "PAYTOP2SHWITNESS" } as const;
-    case 44:
-      return { input: "SPENDADDRESS", output: "PAYTOADDRESS" } as const;
-    default:
-      return null;
-  }
-}
-
-async function getTrezorWallet<T extends Chain>({
-  chain,
-  derivationPath,
-}: { chain: T; derivationPath: DerivationPathArray }) {
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Aurora:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Gnosis:
-    case Chain.Optimism:
-    case Chain.Polygon: {
-      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-      const { getEVMSigner } = await import("./evmSigner");
-
-      const provider = await getProvider(chain);
-      const signer = await getEVMSigner({ chain, derivationPath, provider });
-      const address = await signer.getAddress();
-      const toolbox = await getEvmToolbox(chain, { provider, signer });
-
-      return { ...toolbox, address };
-    }
-
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin: {
-      const { toCashAddress, getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-      const scriptType = getScriptType(derivationPath);
-
-      if (!scriptType) {
-        throw new SwapKitError({
-          errorKey: "wallet_trezor_derivation_path_not_supported",
-          info: { derivationPath },
-        });
-      }
-
-      const coin = chain.toLowerCase();
-
-      const getAddress = async (path: DerivationPathArray = derivationPath) => {
-        const TrezorConnect = (await import("@trezor/connect-web")).default;
-        const { success, payload } = await TrezorConnect.getAddress({
-          path: derivationPathToString(path),
-          coin,
-        });
-
-        if (!success) {
-          throw new SwapKitError({
-            errorKey: "wallet_trezor_failed_to_get_address",
-            info: {
-              chain,
-              error: (payload as { error: string; code?: string }).error || "Unknown error",
-            },
-          });
-        }
-
-        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 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(({ hash, index, value }) => ({
-            // Hardens the first 3 elements of the derivation path - required by trezor
-            address_n,
-            prev_hash: hash,
-            prev_index: index,
-            // object needs amount but does not use it for signing
-            amount: value,
-            script_type: scriptType.input,
-          })),
-          outputs: psbt.txOutputs.map((output) => {
-            // OP_RETURN
-            if (!output.address) {
-              return {
-                amount: "0",
-                op_return_data: Buffer.from(memo).toString("hex"),
-                script_type: "PAYTOOPRETURN",
-              };
-            }
-
-            const outputAddress =
-              chain === Chain.BitcoinCash
-                ? toolbox.stripPrefix(toCashAddress(output.address))
-                : output.address;
-
-            const isChangeAddress = outputAddress === address;
-
-            return isChangeAddress
-              ? { amount: output.value, address_n, script_type: scriptType.output }
-              : { amount: output.value, address: outputAddress, script_type: "PAYTOADDRESS" };
-          }),
-        });
-
-        if (result.success) {
-          return result.payload.serializedTx;
-        }
-
-        throw new SwapKitError({
-          errorKey: "wallet_trezor_failed_to_sign_transaction",
-          info: {
-            chain,
-            error: (result.payload as { error: string; code?: string }).error,
-          },
-        });
-      };
-
-      const transfer = async ({
-        recipient,
-        feeOptionKey,
-        feeRate: paramFeeRate,
-        memo,
-        ...rest
-      }: GenericTransferParams) => {
-        if (!(address && recipient)) {
-          throw new SwapKitError({
-            errorKey: "wallet_missing_params",
-            info: { wallet: WalletOption.TREZOR, memo, address, recipient },
-          });
-        }
-
-        const toolbox = await getUtxoToolbox(chain);
-
-        const feeRate =
-          paramFeeRate || (await toolbox.getFeeRates())[feeOptionKey || FeeOption.Fast];
-
-        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: address,
-          fetchTxHex: true,
-        });
-
-        const txHex = await signTransaction(psbt, inputs, memo);
-        const tx = await toolbox.broadcastTx(txHex);
-
-        return tx;
-      };
-
-      const toolbox = await getUtxoToolbox(chain);
-
-      return { ...toolbox, address, transfer, signTransaction };
-    }
-
-    default:
-      throw new SwapKitError({
-        errorKey: "wallet_chain_not_supported",
-        info: { chain, wallet: WalletOption.TREZOR },
-      });
-  }
-}
-
-export const trezorWallet = createWallet({
-  name: "connectTrezor",
-  walletType: WalletOption.TREZOR,
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Aurora,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Dash,
-    Chain.Dogecoin,
-    Chain.Ethereum,
-    Chain.Gnosis,
-    Chain.Litecoin,
-    Chain.Optimism,
-    Chain.Polygon,
-  ],
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectTrezor(chains: Chain[], derivationPath: DerivationPathArray) {
-      const [chain] = filterSupportedChains({ chains, supportedChains, walletType });
-      if (!chain) {
-        throw new SwapKitError({
-          errorKey: "wallet_chain_not_supported",
-          info: { chain, wallet: WalletOption.TREZOR },
-        });
-      }
-
-      const TrezorConnect = (await import("@trezor/connect-web")).default;
-      const { success } = await TrezorConnect.getDeviceState();
-
-      if (!success) {
-        const trezorConfig = SKConfig.get("integrations").trezor;
-        const manifest = trezorConfig
-          ? {
-              ...trezorConfig,
-              appName: (trezorConfig as any).appName || "SwapKit",
-            }
-          : {
-              appUrl: "",
-              email: "",
-              appName: "SwapKit",
-            };
-        TrezorConnect.init({ lazyLoad: true, manifest });
-      }
-
-      const wallet = await getTrezorWallet({ chain, derivationPath });
-
-      addChain({ ...wallet, chain, walletType });
-
-      return true;
-    },
-});
-
-export const TREZOR_SUPPORTED_CHAINS = getWalletSupportedChains(trezorWallet);