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

package/src/bitget/bitgetWallet.ts

@@ -1,32 +0,0 @@
-import {
-  Chain,
-  EVMChains,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} from "@swapkit/helpers";
-
-import { getWalletSupportedChains } from "../helpers";
-import { getWalletMethods } from "./helpers";
-
-export const bitgetWallet = createWallet({
-  name: "connectBitget",
-  walletType: WalletOption.BITGET,
-  supportedChains: [...EVMChains, Chain.Cosmos, Chain.Bitcoin, Chain.Solana],
-  connect: ({ addChain, walletType, supportedChains }) =>
-    async function connectBitget(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const walletMethods = await getWalletMethods(chain);
-
-          addChain({ ...walletMethods, chain, balance: [], walletType });
-        }),
-      );
-
-      return true;
-    },
-});
-
-export const BITGET_SUPPORTED_CHAINS = getWalletSupportedChains(bitgetWallet);

package/src/ctrl/ctrlWallet.ts

@@ -1,175 +0,0 @@
-import {
-  type AssetValue,
-  Chain,
-  ChainToChainId,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-} from "@swapkit/helpers";
-import type { NonETHToolbox } from "@swapkit/toolboxes/evm";
-
-import { getWalletSupportedChains } from "../helpers";
-import {
-  type WalletTxParams,
-  getCtrlAddress,
-  getCtrlMethods,
-  getCtrlProvider,
-  solanaTransfer,
-  walletTransfer,
-} from "./walletHelpers";
-
-export const ctrlWallet = createWallet({
-  name: "connectCtrl",
-  walletType: WalletOption.CTRL,
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Cosmos,
-    Chain.Dogecoin,
-    Chain.Ethereum,
-    Chain.Kujira,
-    Chain.Litecoin,
-    Chain.Maya,
-    Chain.Optimism,
-    Chain.Polygon,
-    Chain.Solana,
-    Chain.THORChain,
-  ],
-  connect: ({ addChain, walletType, supportedChains }) =>
-    async function connectCtrl(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-
-      const promises = filteredChains.map(async (chain) => {
-        const address = await getCtrlAddress(chain);
-        const walletMethods = await getWalletMethods(chain);
-
-        addChain({ ...walletMethods, address, balance: [], chain, walletType });
-      });
-
-      await Promise.all(promises);
-
-      return true;
-    },
-});
-
-export const CTRL_SUPPORTED_CHAINS = getWalletSupportedChains(ctrlWallet);
-
-async function getWalletMethods(chain: (typeof CTRL_SUPPORTED_CHAINS)[number]) {
-  switch (chain) {
-    case Chain.Solana: {
-      const { SOLToolbox } = await import("@swapkit/toolboxes/solana");
-
-      const toolbox = SOLToolbox();
-      const pubKey = await window.xfi?.solana?.connect();
-
-      if (!pubKey) {
-        throw new SwapKitError("wallet_ctrl_not_found");
-      }
-
-      return { ...toolbox, transfer: solanaTransfer(toolbox, pubKey.publicKey) };
-    }
-
-    case Chain.Maya:
-    case Chain.THORChain: {
-      const { getToolboxByChain, 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);
-
-      return {
-        ...toolbox(),
-        deposit: (tx: WalletTxParams) => walletTransfer({ ...tx, recipient: "" }, "deposit"),
-        transfer: (tx: WalletTxParams) => walletTransfer({ ...tx, gasLimit }, "transfer"),
-      };
-    }
-
-    case Chain.Cosmos:
-    case Chain.Kujira: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/cosmos");
-
-      const chainId = ChainToChainId[chain];
-
-      await window.xfi?.keplr?.enable(chainId);
-      // @ts-ignore
-      const offlineSigner = window.xfi?.keplr?.getOfflineSignerOnlyAmino(chainId);
-
-      const toolbox = getToolboxByChain(chain)();
-
-      const transfer = (params: {
-        from: string;
-        recipient: string;
-        assetValue: AssetValue;
-        memo: string;
-      }) => toolbox.transfer({ signer: offlineSigner, ...params });
-
-      return {
-        ...toolbox,
-
-        transfer,
-      };
-    }
-
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin: {
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/utxo");
-      const toolbox = getToolboxByChain(chain)();
-
-      return { ...toolbox, transfer: walletTransfer };
-    }
-
-    case Chain.Arbitrum:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Optimism:
-    case Chain.Polygon: {
-      const { prepareNetworkSwitch, switchEVMWalletNetwork } = await import("@swapkit/helpers");
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/evm");
-      const { BrowserProvider } = await import("ethers");
-      const ethereumWindowProvider = getCtrlProvider(chain);
-
-      if (!ethereumWindowProvider) {
-        throw new SwapKitError("wallet_ctrl_not_found");
-      }
-
-      const provider = new BrowserProvider(ethereumWindowProvider, "any");
-      const signer = await provider.getSigner();
-      const toolbox = getToolboxByChain(chain)({ provider, signer });
-      const ctrlMethods = getCtrlMethods(provider);
-
-      try {
-        if (chain !== Chain.Ethereum) {
-          const networkParams = (toolbox as NonETHToolbox).getNetworkParams();
-          await switchEVMWalletNetwork(provider, chain, networkParams);
-        }
-      } catch (_error) {
-        throw new SwapKitError({
-          errorKey: "wallet_failed_to_add_or_switch_network",
-          info: { wallet: WalletOption.CTRL, chain },
-        });
-      }
-
-      return prepareNetworkSwitch({
-        provider: window.xfi?.ethereum,
-        chain,
-        toolbox: {
-          ...toolbox,
-          ...ctrlMethods,
-        },
-      });
-    }
-
-    default:
-      return null;
-  }
-}

package/src/helpers.ts

@@ -1,8 +0,0 @@
-import type { createWallet } from "@swapkit/helpers";
-
-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 || [];
-}

package/src/ledger/ledgerLive.ts

@@ -1,429 +0,0 @@
-import type {
-  Account,
-  BitcoinTransaction,
-  CosmosTransaction,
-  EthereumTransaction,
-  Transaction,
-} from "@ledgerhq/wallet-api-client";
-import { FAMILIES, WalletAPIClient, WindowMessageTransport } from "@ledgerhq/wallet-api-client";
-import {
-  AssetValue,
-  BaseDecimal,
-  Chain,
-  FeeOption,
-  SwapKitError,
-  SwapKitNumber,
-  WalletOption,
-  createWallet,
-} from "@swapkit/helpers";
-import { ETHToolbox, getProvider } from "@swapkit/toolboxes/evm";
-import type { UTXOTransferParams } from "@swapkit/toolboxes/utxo";
-import { BigNumber as BigNumberJS } from "bignumber.js";
-import { VoidSigner } from "ethers";
-import { getWalletSupportedChains } from "../helpers";
-
-export type LedgerAccount = Account & { multichainBalance?: AssetValue[] };
-
-export type LedgerLiveTransaction = Transaction;
-export const LEDGER_LIVE_FAMILIES = FAMILIES;
-
-export enum LedgerLiveChain {
-  BTC = "bitcoin",
-  BCH = "bitcoin_cash",
-  LTC = "litecoin",
-  DOGE = "dogecoin",
-  ETH = "ethereum",
-  ARB = "arbitrum",
-  ATOM = "cosmos",
-}
-
-export const ChainToLedgerLiveChain: Partial<Record<Chain, LedgerLiveChain>> = {
-  [Chain.Arbitrum]: LedgerLiveChain.ARB,
-  [Chain.BitcoinCash]: LedgerLiveChain.BCH,
-  [Chain.Bitcoin]: LedgerLiveChain.BTC,
-  [Chain.Cosmos]: LedgerLiveChain.ATOM,
-  [Chain.Dogecoin]: LedgerLiveChain.DOGE,
-  [Chain.Ethereum]: LedgerLiveChain.ETH,
-  [Chain.Litecoin]: LedgerLiveChain.LTC,
-};
-
-export const LedgerLiveChainToChain = {
-  [LedgerLiveChain.ARB]: Chain.Arbitrum,
-  [LedgerLiveChain.ATOM]: Chain.Cosmos,
-  [LedgerLiveChain.BCH]: Chain.BitcoinCash,
-  [LedgerLiveChain.BTC]: Chain.Bitcoin,
-  [LedgerLiveChain.DOGE]: Chain.Dogecoin,
-  [LedgerLiveChain.ETH]: Chain.Ethereum,
-  [LedgerLiveChain.LTC]: Chain.Litecoin,
-};
-
-export const LedgerCurrencyToAsset = {
-  arbitrum: AssetValue.from({ chain: Chain.Arbitrum }),
-  bitcoin: AssetValue.from({ chain: Chain.Bitcoin }),
-  bitcoin_cash: AssetValue.from({ chain: Chain.BitcoinCash }),
-  cosmos: AssetValue.from({ chain: Chain.Cosmos }),
-  dogecoin: AssetValue.from({ chain: Chain.Dogecoin }),
-  ethereum: AssetValue.from({ chain: Chain.Ethereum }),
-  litecoin: AssetValue.from({ chain: Chain.Litecoin }),
-};
-
-export const isLedgerLiveSupportedOutputAsset = ({ chain }: AssetValue) =>
-  [
-    Chain.Arbitrum,
-    Chain.Bitcoin,
-    Chain.BitcoinCash,
-    Chain.Cosmos,
-    Chain.Dogecoin,
-    Chain.Ethereum,
-    Chain.Litecoin,
-  ].includes(chain);
-
-export const isLedgerLiveSupportedInputAsset = (assetInput: AssetValue) =>
-  [
-    AssetValue.from({ chain: Chain.Arbitrum }),
-    AssetValue.from({ chain: Chain.Bitcoin }),
-    AssetValue.from({ chain: Chain.BitcoinCash }),
-    AssetValue.from({ chain: Chain.Cosmos }),
-    AssetValue.from({ chain: Chain.Dogecoin }),
-    AssetValue.from({ chain: Chain.Ethereum }),
-    AssetValue.from({ chain: Chain.Litecoin }),
-    AssetValue.from({ asset: "ARB.USDC-0XAF88D065E77C8CC2239327C5EDB3A432268E5831" }),
-    AssetValue.from({ asset: "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48" }),
-    AssetValue.from({ asset: "ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7" }),
-  ].find((asset) => asset.eq(assetInput));
-
-export const LedgerLive = () => {
-  const transport = new WindowMessageTransport();
-
-  connect();
-
-  const apiClient = new WalletAPIClient(transport);
-
-  function connect() {
-    transport.connect();
-  }
-
-  function disconnect() {
-    transport.disconnect();
-  }
-
-  function listAccounts(chain: Chain) {
-    if (!ChainToLedgerLiveChain[chain]) {
-      throw new Error(`Ledger connect is not supported for ${chain} chain`);
-    }
-
-    return apiClient.account.list({ currencyIds: [ChainToLedgerLiveChain[chain]] });
-  }
-
-  function requestAccounts(chains?: Chain[]) {
-    const filteredChains = chains?.filter((chain) => chain in LEDGER_LIVE_SUPPORTED_CHAINS);
-    if (filteredChains?.length === 0) return Promise.resolve([]);
-    return apiClient.account.request({
-      currencyIds: (filteredChains || LEDGER_LIVE_SUPPORTED_CHAINS).map(
-        (chain) => ChainToLedgerLiveChain[chain] as string,
-      ),
-    });
-  }
-
-  function signTransaction(
-    accountId: string,
-    transaction: LedgerLiveTransaction,
-    params?: {
-      /**
-       * The name of the Ledger Nano app to use for the signing process
-       */
-      hwAppId: string;
-    },
-  ) {
-    return apiClient.transaction.signAndBroadcast(accountId, transaction, params);
-  }
-
-  return {
-    apiClient,
-    connect,
-    disconnect,
-    listAccounts,
-    requestAccounts,
-    signTransaction,
-  };
-};
-
-export const getLedgerLiveWallet = async ({
-  chain,
-  ledgerLiveAccount,
-}: { chain: Chain; ledgerLiveAccount: LedgerAccount }) => {
-  switch (chain) {
-    case Chain.Arbitrum:
-    case Chain.Ethereum: {
-      const getAddress = () => ledgerLiveAccount.address;
-
-      const ledgerLiveClient = EthereumLedgerLive();
-      const provider = getProvider(Chain.Ethereum);
-      const signer = new VoidSigner(ledgerLiveAccount.address, provider);
-
-      const toolbox = ETHToolbox({ provider, signer });
-
-      const sendTransaction = async (unsignedTx: any) => {
-        const signedTx = await ledgerLiveClient?.signTransaction(ledgerLiveAccount.id, {
-          recipient: unsignedTx.to,
-          data: Buffer.from(unsignedTx.data?.substring(2) || "", "hex"),
-          amount: new BigNumberJS(unsignedTx.value || 0),
-          family: "ethereum",
-        });
-        if (!signedTx) throw new Error("Could not sign transaction");
-        return signedTx;
-      };
-
-      const transfer = async ({
-        assetValue,
-        memo,
-        recipient,
-      }: {
-        assetValue: AssetValue;
-        memo: string;
-        recipient: string;
-      }) => {
-        if (!assetValue) throw new Error("invalid asset");
-        const signedTx = await ledgerLiveClient?.signTransaction(ledgerLiveAccount.id, {
-          recipient,
-          data: Buffer.from(memo || ""),
-          amount: new BigNumberJS(assetValue.getBaseValue("string")),
-          family: "ethereum",
-        });
-
-        if (!signedTx) throw new Error("Could not sign transaction");
-
-        return signedTx;
-      };
-
-      return {
-        ...toolbox,
-        getAddress,
-        address: getAddress(),
-        transfer,
-        sendTransaction,
-      };
-    }
-
-    case Chain.Cosmos: {
-      const { GaiaToolbox } = await import("@swapkit/toolboxes/cosmos");
-      const ledgerLiveClient = CosmosLedgerLive();
-      const toolbox = GaiaToolbox();
-
-      const getAddress = () => ledgerLiveAccount.address;
-
-      const getBalance = async () => {
-        const balance = (await ledgerLiveClient.listAccounts(chain)).find(
-          (account) => account.id === ledgerLiveAccount.id,
-        )?.balance;
-
-        return [
-          AssetValue.from({
-            chain: Chain.Cosmos,
-            value: SwapKitNumber.fromBigInt(
-              BigInt(balance?.toString(10) || "0"),
-              BaseDecimal.GAIA,
-            ).getValue("string"),
-          }),
-        ];
-      };
-
-      const sendTransaction = async (unsignedTx: any) => {
-        const signedTx = await ledgerLiveClient?.signTransaction(ledgerLiveAccount.id, {
-          family: "cosmos",
-          recipient: unsignedTx.to,
-          amount: new BigNumberJS(unsignedTx.value || 0),
-          memo: unsignedTx.memo || "",
-          mode: "send",
-        });
-        if (!signedTx) throw new Error("Could not sign transaction");
-        return signedTx;
-      };
-
-      const transfer = async ({
-        assetValue,
-        memo,
-        recipient,
-      }: {
-        assetValue: AssetValue;
-        memo: string;
-        recipient: string;
-      }) => {
-        if (!assetValue) throw new Error("invalid asset");
-        const signedTx = await ledgerLiveClient?.signTransaction(ledgerLiveAccount.id, {
-          family: "cosmos",
-          recipient,
-          amount: new BigNumberJS(assetValue.getBaseValue("string")),
-          memo,
-          mode: "send",
-        });
-
-        if (!signedTx) throw new Error("Could not sign transaction");
-
-        return signedTx;
-      };
-
-      return {
-        ...toolbox,
-        getBalance,
-        getAddress,
-        address: getAddress(),
-        transfer,
-        sendTransaction,
-      };
-    }
-    case Chain.Litecoin:
-    case Chain.BitcoinCash:
-    case Chain.Dogecoin:
-    case Chain.Bitcoin: {
-      const ledgerLiveClient = BitcoinLedgerLive();
-      const { getToolboxByChain } = await import("@swapkit/toolboxes/utxo");
-      const toolbox = getToolboxByChain(chain)();
-
-      const getAddress = () => ledgerLiveAccount.address;
-
-      const getBalance = async () => {
-        const balance = (await ledgerLiveClient.listAccounts(chain)).find(
-          (account) => account.id === ledgerLiveAccount.id,
-        )?.balance;
-
-        return [
-          AssetValue.from({
-            chain,
-            value: SwapKitNumber.fromBigInt(
-              BigInt(balance?.toString(10) || "0"),
-              BaseDecimal.BTC,
-            ).getValue("string"),
-          }),
-        ];
-      };
-
-      const sendTransaction = async (unsignedTx: any) => {
-        const signedTx = await ledgerLiveClient?.signTransaction(ledgerLiveAccount.id, {
-          recipient: unsignedTx.to,
-          opReturnData: Buffer.from(unsignedTx.memo || ""),
-          amount: new BigNumberJS(unsignedTx.value || 0),
-          family: "bitcoin",
-        });
-        if (!signedTx) throw new Error("Could not sign transaction");
-        return signedTx;
-      };
-
-      const transfer = async ({ assetValue, memo, recipient, feeRate }: UTXOTransferParams) => {
-        if (!assetValue) throw new Error("invalid asset");
-        const gasPrice = (await toolbox.getFeeRates())[FeeOption.Average];
-        const signedTx = await ledgerLiveClient?.signTransaction(ledgerLiveAccount.id, {
-          recipient,
-          opReturnData: Buffer.from(memo || ""),
-          amount: new BigNumberJS(assetValue.getBaseValue("string")),
-          feePerByte: feeRate ? new BigNumberJS(Math.max(feeRate, gasPrice)) : undefined,
-          family: "bitcoin",
-        });
-
-        if (!signedTx) throw new Error("Could not sign transaction");
-
-        return signedTx;
-      };
-
-      return {
-        ...toolbox,
-        getBalance,
-        getAddress,
-        address: getAddress(),
-        transfer,
-        sendTransaction,
-      };
-    }
-    default:
-      throw new SwapKitError("wallet_chain_not_supported");
-  }
-};
-
-export const EthereumLedgerLive = () => {
-  const baseLedgerLiveClient = LedgerLive();
-
-  function signTransaction(
-    accountId: string,
-    transaction: EthereumTransaction,
-    params?: { hwAppId: string } | undefined,
-  ) {
-    return baseLedgerLiveClient.apiClient.transaction.signAndBroadcast(
-      accountId,
-      transaction,
-      params,
-    );
-  }
-
-  return { ...baseLedgerLiveClient, signTransaction };
-};
-
-export const BitcoinLedgerLive = () => {
-  const baseLedgerLiveClient = LedgerLive();
-
-  function signTransaction(
-    accountId: string,
-    transaction: BitcoinTransaction,
-    params?: { hwAppId: string } | undefined,
-  ) {
-    return baseLedgerLiveClient.apiClient.transaction.signAndBroadcast(
-      accountId,
-      transaction,
-      params,
-    );
-  }
-
-  return {
-    ...baseLedgerLiveClient,
-    signTransaction,
-  };
-};
-
-export const CosmosLedgerLive = () => {
-  const baseLedgerLiveClient = LedgerLive();
-
-  function signTransaction(
-    accountId: string,
-    transaction: CosmosTransaction,
-    params?: { hwAppId: string } | undefined,
-  ) {
-    return baseLedgerLiveClient.apiClient.transaction.signAndBroadcast(
-      accountId,
-      transaction,
-      params,
-    );
-  }
-
-  return {
-    ...baseLedgerLiveClient,
-    signTransaction,
-  };
-};
-
-export const ledgerLiveWallet = createWallet({
-  name: "connectLedgerLive",
-  walletType: WalletOption.LEDGER_LIVE,
-  supportedChains: [
-    Chain.Bitcoin,
-    Chain.Ethereum,
-    Chain.Cosmos,
-    Chain.Litecoin,
-    Chain.Dogecoin,
-    Chain.BitcoinCash,
-  ],
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectLedgerLive(
-      chains: (typeof supportedChains)[number][],
-      ledgerLiveAccount: LedgerAccount,
-    ) {
-      const [chain] = chains;
-      if (!chain) return false;
-
-      const toolbox = await getLedgerLiveWallet({ chain, ledgerLiveAccount });
-
-      addChain({ ...toolbox, chain, balance: [], walletType });
-
-      return true;
-    },
-});
-
-export const LEDGER_LIVE_SUPPORTED_CHAINS = getWalletSupportedChains(ledgerLiveWallet);