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

package/src/vultisig/walletHelpers.ts

@@ -1,359 +0,0 @@
-import {
-  type AssetValue,
-  Chain,
-  ChainToChainId,
-  type EVMChain,
-  EVMChains,
-  type FeeOption,
-  type NetworkParams,
-  SwapKitError,
-  type UTXOChain,
-  WalletOption,
-  providerRequest,
-} from "@swapkit/helpers";
-import { erc20ABI } from "@swapkit/helpers/contracts";
-import type { getCosmosToolbox } from "@swapkit/toolboxes/cosmos";
-import type { ApproveParams, CallParams, EVMTxParams } from "@swapkit/toolboxes/evm";
-import type { SolanaProvider } from "@swapkit/toolboxes/solana";
-import type { BrowserProvider, Eip1193Provider } from "ethers";
-import type { VultisigCosmosProvider } from "../types";
-
-type TransactionMethod = "send_transaction" | "deposit_transaction";
-
-type TransactionParams = {
-  asset: string | { chain: string; symbol: string; ticker: string };
-  amount: number | string | { amount: number; decimals?: number };
-  decimal?: number;
-  to: string;
-  data?: string;
-  from?: string;
-};
-
-export type WalletTxParams = {
-  feeOptionKey?: FeeOption;
-  from?: string;
-  memo?: string;
-  recipient: string;
-  assetValue: AssetValue;
-  gasLimit?: string | bigint;
-};
-
-type VultisigProviderType<T> = T extends Chain.Solana
-  ? SolanaProvider
-  : T extends Chain.Cosmos | Chain.Kujira
-    ? VultisigCosmosProvider
-    : T extends EVMChain
-      ? Eip1193Provider
-      : T extends Chain.Maya | Chain.THORChain | Chain.Ripple | Chain.Polkadot | UTXOChain
-        ? Eip1193Provider
-        : undefined;
-
-export async function getVultisigProvider<T extends Chain>(
-  chain: T,
-): Promise<VultisigProviderType<T>> {
-  if (!window.vultisig) throw new SwapKitError("wallet_vultisig_not_found");
-  const { match } = await import("ts-pattern");
-
-  return match(chain as Chain)
-    .with(...EVMChains, () => window.vultisig?.ethereum as Eip1193Provider)
-    .with(Chain.Cosmos, Chain.Kujira, () => window.vultisig?.cosmos as VultisigCosmosProvider)
-    .with(Chain.Bitcoin, () => window.vultisig?.bitcoin as Eip1193Provider)
-    .with(Chain.BitcoinCash, () => window.vultisig?.bitcoincash as Eip1193Provider)
-    .with(Chain.Dash, () => window.vultisig?.dash as Eip1193Provider)
-    .with(Chain.Dogecoin, () => window.vultisig?.dogecoin as Eip1193Provider)
-    .with(Chain.Litecoin, () => window.vultisig?.litecoin as Eip1193Provider)
-    .with(Chain.Solana, () => window.vultisig?.solana as SolanaProvider)
-    .with(Chain.THORChain, () => window.vultisig?.thorchain as Eip1193Provider)
-    .with(Chain.Maya, () => window.vultisig?.mayachain as Eip1193Provider)
-    .with(Chain.Polkadot, () => window.vultisig?.polkadot as Eip1193Provider)
-    .with(Chain.Ripple, () => window.vultisig?.ripple as Eip1193Provider)
-    .with(Chain.Zcash, () => window.vultisig?.zcash as Eip1193Provider)
-    .otherwise(() => undefined) as VultisigProviderType<T>;
-}
-
-async function transaction({
-  method,
-  params,
-  chain,
-}: {
-  method: TransactionMethod;
-  params: TransactionParams[];
-  chain: Chain;
-}): Promise<string> {
-  const client = await getVultisigProvider(chain);
-  let finalParams:
-    | TransactionParams[]
-    | {
-        from: string;
-        to?: string;
-        value: string;
-        data?: string;
-      }[] = params;
-
-  if (chain === Chain.Cosmos || chain === Chain.Kujira || chain === Chain.Ripple) {
-    finalParams = params.map((p) => ({
-      from: p.from as string,
-      to: p.to as string,
-      value: (p.amount as { amount: number; decimals?: number }).amount.toString(),
-      data: p.data as string,
-    }));
-  }
-
-  return new Promise<string>((resolve, reject) => {
-    if (client && "request" in client) {
-      // @ts-ignore
-      client.request({ method, params: finalParams }, (err: string, tx: string) => {
-        err ? reject(err) : resolve(tx);
-      });
-    }
-  });
-}
-
-export async function getVultisigAddress(chain: Chain) {
-  try {
-    const eipProvider = (await getVultisigProvider(chain)) as Eip1193Provider;
-    if (!eipProvider) {
-      throw new SwapKitError({
-        errorKey: "wallet_provider_not_found",
-        info: { wallet: WalletOption.VULTISIG, chain },
-      });
-    }
-
-    if ([Chain.Cosmos, Chain.Kujira].includes(chain)) {
-      const provider = await getVultisigProvider(Chain.Cosmos);
-      const chainId = ChainToChainId[chain];
-
-      await provider.request({
-        method: "wallet_switch_chain",
-        params: [{ chainId }],
-      });
-
-      let account = await provider.request({
-        method: "get_accounts",
-      });
-      if (!account) {
-        const connectedAcount = await provider.request({
-          method: "request_accounts",
-        });
-        account = connectedAcount[0].address;
-      }
-      return account;
-    }
-
-    if (EVMChains.includes(chain as EVMChain)) {
-      if ("request" in eipProvider && typeof eipProvider.request === "function") {
-        const accounts = await eipProvider.request({ method: "eth_requestAccounts" });
-        return accounts[0];
-      }
-      const { BrowserProvider } = await import("ethers");
-      const provider = new BrowserProvider(eipProvider, "any");
-      const [response] = await providerRequest({
-        provider,
-        method: "eth_requestAccounts",
-        params: [],
-      });
-      return response;
-    }
-
-    if (chain === Chain.Solana) {
-      const provider = await getVultisigProvider(Chain.Solana);
-
-      const accounts = await provider.connect();
-      return accounts.publicKey.toString();
-    }
-
-    const accounts = await eipProvider.request({ method: "request_accounts", params: [] });
-    return accounts[0];
-  } catch (_error) {
-    throw new SwapKitError({
-      errorKey: "wallet_provider_not_found",
-      info: { wallet: WalletOption.VULTISIG, chain },
-    });
-  }
-}
-
-export async function walletTransfer(
-  { assetValue, recipient, memo, gasLimit }: WalletTxParams,
-  method: TransactionMethod = "send_transaction",
-) {
-  if (!assetValue) {
-    throw new SwapKitError("wallet_vultisig_asset_not_defined");
-  }
-
-  /**
-   * EVM requires amount to be hex string
-   * UTXO/Cosmos requires amount to be number
-   */
-
-  const from = await getVultisigAddress(assetValue.chain);
-  const params = [
-    {
-      amount: {
-        amount: assetValue.getBaseValue("number"),
-        decimals: assetValue.decimal,
-      },
-      asset: {
-        chain: assetValue.chain,
-        symbol: assetValue.symbol.toUpperCase(),
-        ticker: assetValue.symbol.toUpperCase(),
-      },
-      data: memo || "",
-      from,
-      to: recipient,
-      gasLimit,
-    },
-  ];
-
-  return transaction({ method, params, chain: assetValue.chain });
-}
-
-export function getVultisigMethods(provider: BrowserProvider, chain: EVMChain) {
-  return {
-    call: async <T>({
-      contractAddress,
-      abi,
-      funcName,
-      funcParams = [],
-      txOverrides,
-    }: CallParams): Promise<T> => {
-      if (!contractAddress) {
-        throw new SwapKitError("wallet_vultisig_contract_address_not_provided");
-      }
-      const { createContract, getCreateContractTxObject, isStateChangingCall } = await import(
-        "@swapkit/toolboxes/evm"
-      );
-
-      const isStateChanging = isStateChangingCall({ abi, funcName });
-
-      if (isStateChanging) {
-        const createTx = getCreateContractTxObject({ provider, chain });
-        const { value, from, to, data } = await createTx({
-          contractAddress,
-          abi,
-          funcName,
-          funcParams,
-          txOverrides,
-        });
-
-        const signer = await provider.getSigner();
-        const tx = await signer.sendTransaction({
-          value: BigInt(value || 0),
-          from,
-          to,
-          data: data || "0x",
-        });
-        return tx.hash as T;
-      }
-      const contract = createContract(contractAddress, abi, provider);
-
-      const result = await contract[funcName]?.(...funcParams);
-
-      return typeof result?.hash === "string" ? result?.hash : result;
-    },
-    approve: async ({ assetAddress, spenderAddress, amount, from }: ApproveParams) => {
-      const { MAX_APPROVAL, getCreateContractTxObject } = await import("@swapkit/toolboxes/evm");
-      const funcParams = [spenderAddress, BigInt(amount || MAX_APPROVAL)];
-      const txOverrides = { from };
-
-      const functionCallParams = {
-        contractAddress: assetAddress,
-        abi: erc20ABI,
-        funcName: "approve",
-        funcParams,
-        txOverrides,
-      };
-
-      const createTx = getCreateContractTxObject({ provider, chain });
-      const { value, to, data } = await createTx(functionCallParams);
-
-      const signer = await provider.getSigner();
-      const tx = await signer.sendTransaction({
-        value: BigInt(value || 0),
-        from,
-        to,
-        data: data || "0x",
-      });
-      return tx.hash;
-    },
-    sendTransaction: async (txParams: EVMTxParams) => {
-      const { from, to, data, value } = txParams;
-      if (!to) {
-        throw new SwapKitError("wallet_vultisig_send_transaction_no_address");
-      }
-
-      const signer = await provider.getSigner();
-      const tx = await signer.sendTransaction({
-        value: BigInt(value || 0),
-        from,
-        to,
-        data: data || "0x",
-      });
-      return tx.hash;
-    },
-  };
-}
-
-export async function switchCosmosWalletNetwork(
-  provider: VultisigCosmosProvider,
-  chain: Chain.Cosmos | Chain.Kujira,
-  networkParams?: NetworkParams,
-) {
-  try {
-    await provider.request({
-      method: "wallet_switch_chain",
-      params: [{ chainId: ChainToChainId[chain] }],
-    });
-  } catch (error) {
-    if (!networkParams) {
-      throw new SwapKitError("helpers_failed_to_switch_network", {
-        error: error,
-        reason: "networkParams not provided",
-      });
-    }
-  }
-}
-
-export function wrapMethodWithNetworkSwitch<T extends (...args: any[]) => any>(
-  func: T,
-  provider: VultisigCosmosProvider,
-  chain: Chain.Cosmos | Chain.Kujira,
-) {
-  return (async (...args: any[]) => {
-    try {
-      await switchCosmosWalletNetwork(provider, chain);
-    } catch (error) {
-      throw new SwapKitError({
-        errorKey: "helpers_failed_to_switch_network",
-        info: { error },
-      });
-    }
-    return func(...args);
-  }) as unknown as T;
-}
-
-export function prepareNetworkSwitchCosmos<
-  T extends Awaited<ReturnType<typeof getCosmosToolbox>>,
-  M extends keyof T,
->({
-  toolbox,
-  chain,
-  provider = window.ethereum,
-  methodNames = [],
-}: { toolbox: T; chain: Chain; provider?: VultisigCosmosProvider; methodNames?: M[] }) {
-  const methodsToWrap = [...methodNames, "transfer", "getAddress", "getBalance"] as M[];
-  const wrappedMethods = methodsToWrap.reduce((object, methodName) => {
-    if (!toolbox[methodName]) return object;
-
-    const method = toolbox[methodName];
-
-    if (typeof method !== "function") return object;
-
-    // @ts-expect-error
-    const wrappedMethod = wrapMethodWithNetworkSwitch(method, provider, chain);
-
-    // biome-ignore lint/performance/noAccumulatingSpread: valid use case
-    return { ...object, [methodName]: wrappedMethod };
-  }, {});
-
-  return { ...toolbox, ...wrappedMethods };
-}

package/src/walletconnect/constants.ts

@@ -1,104 +0,0 @@
-import type { ClientMetadata } from "./types";
-
-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 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";
-export const MAYACHAIN_MAINNET_ID = "cosmos:mayachain-mainnet-v1";
-export const ARBITRUM_ONE_MAINNET_ID = "eip155:42161";
-export const OPTIMISM_MAINNET_ID = "eip155:10";
-export const POLYGON_MAINNET_ID = "eip155:137";
-export const BASE_MAINNET_ID = "eip155:8453";
-export const NEAR_MAINNET_ID = "near:mainnet";
-export const NEAR_TESTNET_ID = "near:testnet";
-export const TRON_MAINNET_ID = "tron:0x2b6653dc";
-export const AURORA_MAINNET_ID = "eip155:1313161554";
-export const BERACHAIN_MAINNET_ID = "eip155:80094";
-
-export const DEFAULT_LOGGER = "debug";
-
-export const DEFAULT_APP_METADATA: ClientMetadata = {
-  name: "SwapKit",
-  description: "SwapKit cross-chain SDK",
-  url: "https://swapkit.dev/",
-  icons: [
-    "https://raw.githubusercontent.com/swapkit/SwapKit/refs/heads/develop/docs/src/assets/logo-black.png",
-  ],
-};
-
-/**
- * EIP155
- */
-export enum DEFAULT_EIP155_METHODS {
-  ETH_SEND_TRANSACTION = "eth_sendTransaction",
-  // not supported by most WC wallets
-  // ETH_SIGN_TRANSACTION = 'eth_signTransaction',
-  ETH_SIGN = "eth_sign",
-  PERSONAL_SIGN = "personal_sign",
-  ETH_SIGN_TYPED_DATA = "eth_signTypedData",
-}
-
-export enum DEFAULT_EIP_155_EVENTS {
-  ETH_CHAIN_CHANGED = "chainChanged",
-  ETH_ACCOUNTS_CHANGED = "accountsChanged",
-}
-
-/**
- * COSMOS
- */
-export enum DEFAULT_COSMOS_METHODS {
-  COSMOS_SIGN_DIRECT = "cosmos_signDirect",
-  COSMOS_SIGN_AMINO = "cosmos_signAmino",
-  COSMOS_GET_ACCOUNTS = "cosmos_getAccounts",
-}
-
-export enum DEFAULT_COSMOS_EVENTS {}
-
-/**
- * SOLANA
- */
-export enum DEFAULT_SOLANA_METHODS {
-  SOL_SIGN_TRANSACTION = "solana_signTransaction",
-  SOL_SIGN_MESSAGE = "solana_signMessage",
-}
-
-export enum DEFAULT_SOLANA_EVENTS {}
-
-/**
- * POLKADOT
- */
-export enum DEFAULT_POLKADOT_METHODS {
-  POLKADOT_SIGN_TRANSACTION = "polkadot_signTransaction",
-  POLKADOT_SIGN_MESSAGE = "polkadot_signMessage",
-}
-
-export enum DEFAULT_POLKADOT_EVENTS {}
-
-/**
- * NEAR
- */
-export enum DEFAULT_NEAR_METHODS {
-  NEAR_SIGN_IN = "near_signIn",
-  NEAR_SIGN_OUT = "near_signOut",
-  NEAR_GET_ACCOUNTS = "near_getAccounts",
-  NEAR_SIGN_AND_SEND_TRANSACTION = "near_signAndSendTransaction",
-  NEAR_SIGN_AND_SEND_TRANSACTIONS = "near_signAndSendTransactions",
-}
-
-export enum DEFAULT_NEAR_EVENTS {}
-
-/**
- * TRON
- */
-export enum DEFAULT_TRON_METHODS {
-  TRON_SIGN_MESSAGE = "tron_signMessage",
-  TRON_SIGN_TRANSACTION = "tron_signTransaction",
-  TRON_SEND_TRANSACTION = "tron_sendTransaction",
-  TRON_GET_ACCOUNTS = "tron_getAccounts",
-}
-
-export enum DEFAULT_TRON_EVENTS {}

package/src/walletconnect/evmSigner.ts

@@ -1,147 +0,0 @@
-import { type EVMChain, SwapKitError, WalletOption } from "@swapkit/helpers";
-import type { JsonRpcProvider, Provider, TransactionRequest, TransactionResponse } from "ethers";
-import { AbstractSigner } from "ethers";
-
-import { DEFAULT_EIP155_METHODS } from "./constants";
-import { chainToChainId, getAddressByChain } from "./helpers";
-import type { Walletconnect } from "./index";
-
-interface WalletconnectEVMSignerParams {
-  chain: EVMChain;
-  walletconnect: Walletconnect;
-  provider: Provider | JsonRpcProvider;
-}
-
-class WalletconnectSigner extends AbstractSigner {
-  address: string;
-
-  private chain: EVMChain;
-  private walletconnect: Walletconnect;
-  readonly provider: Provider | JsonRpcProvider;
-
-  constructor({ chain, provider, walletconnect }: WalletconnectEVMSignerParams) {
-    super(provider);
-    this.chain = chain;
-    this.walletconnect = walletconnect;
-    this.provider = provider;
-    this.address = "";
-  }
-
-  // biome-ignore lint/suspicious/useAwait: fulfil implementation type
-  getAddress = async () => {
-    if (!this.walletconnect) {
-      throw new SwapKitError("wallet_walletconnect_connection_not_established");
-    }
-    if (!this.address) {
-      this.address = getAddressByChain(this.chain, this.walletconnect.accounts || []);
-    }
-
-    return this.address;
-  };
-
-  signMessage = async (message: string) => {
-    // this is probably broken
-    const txHash = (await this.walletconnect?.client.request({
-      chainId: chainToChainId(this.chain),
-      topic: this.walletconnect.session.topic || "",
-      request: {
-        method: DEFAULT_EIP155_METHODS.ETH_SIGN,
-        params: [message],
-      },
-    })) as string;
-
-    return txHash.startsWith("0x") ? txHash : `0x${txHash}`;
-  };
-
-  signTransaction = () => {
-    throw new SwapKitError("wallet_walletconnect_method_not_supported", {
-      method: "signTransaction",
-    });
-
-    // const baseTx = {
-    //   from,
-    //   to,
-    //   value: BigNumber.from(value || 0).toHexString(),
-    //   data,
-    // };
-
-    // const txHash = (await this.walletconnect?.client.request({
-    //   chainId: chainToChainId(this.chain),
-    //   topic: this.walletconnect.session.topic,
-    //   request: {
-    //     method: DEFAULT_EIP155_METHODS.ETH_SIGN_TRANSACTION,
-    //     params: [baseTx],
-    //   },
-    // })) as string;
-
-    // return txHash.startsWith('0x') ? txHash : `0x${txHash}`;
-  };
-
-  // ANCHOR (@Towan) - Implement in future
-  signTypedData = () => {
-    throw new SwapKitError("wallet_walletconnect_method_not_supported", {
-      method: "signTypedData",
-    });
-
-    // const { toHexString } = await import('@swapkit/toolboxes/evm');
-
-    // const baseTx = {
-    //   from,
-    //   to,
-    //   value: toHexString(value || 0n),
-    //   data,
-    // };
-
-    // const txHash = (await this.walletconnect?.client.request({
-    //   chainId: chainToChainId(this.chain),
-    //   topic: this.walletconnect.session.topic,
-    //   request: {
-    //     method: DEFAULT_EIP155_METHODS.ETH_SIGN_TYPED_DATA,
-    //     params: [baseTx],
-    //   },
-    // })) as string;
-
-    // return txHash.startsWith('0x') ? txHash : `0x${txHash}`;
-  };
-
-  sendTransaction = async ({ from, to, value, data }: TransactionRequest) => {
-    const { toHexString } = await import("@swapkit/toolboxes/evm");
-
-    const baseTx = {
-      from,
-      to,
-      value: toHexString(BigInt(value || 0)),
-      data,
-    };
-    const response = await this.walletconnect?.client.request({
-      chainId: chainToChainId(this.chain),
-      topic: this.walletconnect.session.topic,
-      request: {
-        method: DEFAULT_EIP155_METHODS.ETH_SEND_TRANSACTION,
-        params: [baseTx],
-      },
-    });
-
-    return response as TransactionResponse;
-  };
-
-  connect = (provider: Provider | null) => {
-    if (!provider) {
-      throw new SwapKitError({
-        errorKey: "wallet_provider_not_found",
-        info: { wallet: WalletOption.WALLETCONNECT, chain: this.chain },
-      });
-    }
-
-    return new WalletconnectSigner({
-      chain: this.chain,
-      walletconnect: this.walletconnect,
-      provider,
-    });
-  };
-}
-export const getEVMSigner = async ({
-  chain,
-  walletconnect,
-  provider,
-}: WalletconnectEVMSignerParams) => new WalletconnectSigner({ chain, walletconnect, provider });

package/src/walletconnect/helpers.ts

@@ -1,77 +0,0 @@
-import { Chain, type EVMChain, SKConfig } from "@swapkit/helpers";
-
-import {
-  ARBITRUM_ONE_MAINNET_ID,
-  AURORA_MAINNET_ID,
-  AVALANCHE_MAINNET_ID,
-  BASE_MAINNET_ID,
-  BERACHAIN_MAINNET_ID,
-  BSC_MAINNET_ID,
-  COSMOS_HUB_MAINNET_ID,
-  ETHEREUM_MAINNET_ID,
-  KUJIRA_MAINNET_ID,
-  MAYACHAIN_MAINNET_ID,
-  NEAR_MAINNET_ID,
-  NEAR_TESTNET_ID,
-  OPTIMISM_MAINNET_ID,
-  POLYGON_MAINNET_ID,
-  THORCHAIN_MAINNET_ID,
-  TRON_MAINNET_ID,
-} from "./constants";
-
-export const getAddressByChain = (
-  chain:
-    | EVMChain
-    | Chain.THORChain
-    | Chain.Maya
-    | Chain.Kujira
-    | Chain.Cosmos
-    | Chain.Near
-    | Chain.Tron,
-  accounts: string[],
-) => {
-  const account = accounts.find((account) => account.startsWith(chainToChainId(chain))) || "";
-  const address = account?.split(":")?.[2];
-
-  return address || "";
-};
-
-export const chainToChainId = (chain: Chain) => {
-  switch (chain) {
-    case Chain.Avalanche:
-      return AVALANCHE_MAINNET_ID;
-    case Chain.Aurora:
-      return AURORA_MAINNET_ID;
-    case Chain.Base:
-      return BASE_MAINNET_ID;
-    case Chain.BinanceSmartChain:
-      return BSC_MAINNET_ID;
-    case Chain.Berachain:
-      return BERACHAIN_MAINNET_ID;
-    case Chain.Ethereum:
-      return ETHEREUM_MAINNET_ID;
-    case Chain.THORChain:
-      return THORCHAIN_MAINNET_ID;
-    case Chain.Arbitrum:
-      return ARBITRUM_ONE_MAINNET_ID;
-    case Chain.Optimism:
-      return OPTIMISM_MAINNET_ID;
-    case Chain.Polygon:
-      return POLYGON_MAINNET_ID;
-    case Chain.Maya:
-      return MAYACHAIN_MAINNET_ID;
-    case Chain.Cosmos:
-      return COSMOS_HUB_MAINNET_ID;
-    case Chain.Kujira:
-      return KUJIRA_MAINNET_ID;
-    case Chain.Near: {
-      // Use testnet if stagenet is enabled
-      const { isStagenet } = SKConfig.get("envs");
-      return isStagenet ? NEAR_TESTNET_ID : NEAR_MAINNET_ID;
-    }
-    case Chain.Tron:
-      return TRON_MAINNET_ID;
-    default:
-      return "";
-  }
-};