@swapkit/wallets 4.0.0-beta.53 → 4.0.0-beta.55

package/src/ledger/interfaces/CosmosLedgerInterface.ts

@@ -1,65 +0,0 @@
-import {
-  type DerivationPathArray,
-  LedgerErrorCode,
-  NetworkDerivationPath,
-  SwapKitError,
-} from "@swapkit/helpers";
-
-import { THORChainApp } from "../clients/thorchain/lib";
-import { getLedgerTransport } from "../helpers/getLedgerTransport";
-
-export abstract class CosmosLedgerInterface {
-  ledgerTimeout = 50000;
-  derivationPath: DerivationPathArray | string = NetworkDerivationPath.GAIA;
-  transport: any;
-  ledgerApp: any;
-  chain: "thor" | "cosmos" = "thor";
-
-  checkOrCreateTransportAndLedger = async (forceReconnect = false) => {
-    if (!forceReconnect && this.transport && this.ledgerApp) return;
-
-    try {
-      this.transport =
-        forceReconnect || !this.transport ? await getLedgerTransport() : this.transport;
-
-      // biome-ignore lint/style/useDefaultSwitchClause: default will never be hit
-      switch (this.chain) {
-        case "thor": {
-          this.ledgerApp =
-            forceReconnect || !this.ledgerApp ? new THORChainApp(this.transport) : this.ledgerApp;
-
-          break;
-        }
-
-        case "cosmos": {
-          const CosmosApp = (await import("@ledgerhq/hw-app-cosmos")).default;
-          this.ledgerApp =
-            forceReconnect || !this.ledgerApp ? new CosmosApp(this.transport) : this.ledgerApp;
-        }
-      }
-
-      return this.ledgerApp;
-    } catch (error: unknown) {
-      throw new SwapKitError("wallet_ledger_connection_error", error);
-    }
-  };
-
-  validateResponse = (errorCode: LedgerErrorCode, message?: string) => {
-    switch (errorCode) {
-      case LedgerErrorCode.NoError:
-        return;
-
-      case LedgerErrorCode.LockedDevice:
-        throw new SwapKitError("wallet_ledger_device_locked", {
-          message: `Ledger is locked: ${message}`,
-        });
-
-      case LedgerErrorCode.TC_NotFound:
-        throw new SwapKitError("wallet_ledger_device_not_found");
-
-      default: {
-        break;
-      }
-    }
-  };
-}

package/src/ledger/types.ts

@@ -1,45 +0,0 @@
-import type { CosmosLedger } from "./clients/cosmos";
-import type {
-  ArbitrumLedger,
-  AuroraLedger,
-  AvalancheLedger,
-  BaseLedger,
-  BinanceSmartChainLedger,
-  EthereumLedger,
-  GnosisLedger,
-  OptimismLedger,
-  PolygonLedger,
-} from "./clients/evm";
-import type { THORChainLedger } from "./clients/thorchain";
-import type { TronLedger } from "./clients/tron";
-import type {
-  BitcoinCashLedger,
-  BitcoinLedger,
-  DogecoinLedger,
-  LitecoinLedger,
-} from "./clients/utxo";
-
-export type UTXOLedgerClients =
-  | ReturnType<typeof BitcoinLedger>
-  | ReturnType<typeof BitcoinCashLedger>
-  | ReturnType<typeof DogecoinLedger>
-  | ReturnType<typeof LitecoinLedger>;
-export type CosmosLedgerClients = CosmosLedger | THORChainLedger;
-export type EVMLedgerClients =
-  | ReturnType<typeof ArbitrumLedger>
-  | ReturnType<typeof AuroraLedger>
-  | ReturnType<typeof AvalancheLedger>
-  | ReturnType<typeof BaseLedger>
-  | ReturnType<typeof BinanceSmartChainLedger>
-  | ReturnType<typeof GnosisLedger>
-  | ReturnType<typeof EthereumLedger>
-  | ReturnType<typeof OptimismLedger>
-  | ReturnType<typeof PolygonLedger>;
-export type TronLedgerClient = ReturnType<typeof TronLedger>;
-
-export type GetAddressAndPubKeyResponse = {
-  bech32_address: string;
-  compressed_pk: any;
-  error_message: string;
-  return_code: number;
-};

package/src/okx/helpers.ts

@@ -1,181 +0,0 @@
-import {
-  Chain,
-  ChainId,
-  type EVMChain,
-  type GenericTransferParams,
-  SKConfig,
-  SwapKitError,
-  prepareNetworkSwitch,
-  switchEVMWalletNetwork,
-} from "@swapkit/helpers";
-import type { TronSigner, TronTransaction } from "@swapkit/toolboxes/tron";
-import { Psbt } from "bitcoinjs-lib";
-import type { Eip1193Provider } from "ethers";
-
-const cosmosTransfer =
-  (sender: string) =>
-  async ({ recipient, assetValue, memo }: GenericTransferParams) => {
-    if (!(window.okxwallet && "keplr" in window.okxwallet)) {
-      throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Cosmos });
-    }
-    const { createSigningStargateClient } = await import("@swapkit/toolboxes/cosmos");
-
-    const { keplr: wallet } = window.okxwallet;
-    const offlineSigner = wallet?.getOfflineSignerOnlyAmino(ChainId.Cosmos);
-
-    const cosmJS = await createSigningStargateClient(SKConfig.get("rpcUrls").GAIA, offlineSigner);
-
-    const coins = [
-      {
-        denom: assetValue?.symbol === "MUON" ? "umuon" : "uatom",
-        amount: assetValue.getBaseValue("string"),
-      },
-    ];
-
-    const { transactionHash } = await cosmJS.sendTokens(sender, recipient, coins, 1.6, memo);
-    return transactionHash;
-  };
-
-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("wallet_okx_not_found");
-
-  const provider = new BrowserProvider(walletProvider, "any");
-  const signer = await provider.getSigner();
-  const toolbox = await getEvmToolbox(chain, { provider, signer });
-
-  try {
-    if (chain !== Chain.Ethereum && "getNetworkParams" in toolbox) {
-      await switchEVMWalletNetwork(provider, chain, toolbox.getNetworkParams());
-    }
-  } catch (_error) {
-    throw new SwapKitError("wallet_okx_failed_to_switch_network", { chain });
-  }
-
-  return prepareNetworkSwitch({ toolbox, provider, chain });
-}
-
-export async function getWalletMethods(chain: Chain) {
-  const { match, P } = await import("ts-pattern");
-
-  return match(chain)
-    .with(
-      P.union(
-        Chain.Arbitrum,
-        Chain.Aurora,
-        Chain.Avalanche,
-        Chain.Base,
-        Chain.Berachain,
-        Chain.BinanceSmartChain,
-        Chain.Ethereum,
-        Chain.Gnosis,
-        Chain.Optimism,
-        Chain.Polygon,
-      ),
-      async () => {
-        if (!(window.okxwallet && "send" in window.okxwallet)) {
-          throw new SwapKitError("wallet_okx_not_found", { chain });
-        }
-
-        const evmWallet = await getWeb3WalletMethods({
-          chain: chain as EVMChain,
-          walletProvider: window.okxwallet,
-        });
-        const address: string = (await window.okxwallet.send("eth_requestAccounts", [])).result[0];
-
-        return { ...evmWallet, address };
-      },
-    )
-    .with(Chain.Bitcoin, async () => {
-      if (!(window.okxwallet && "bitcoin" in window.okxwallet)) {
-        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Bitcoin });
-      }
-
-      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-
-      const { bitcoin: wallet } = window.okxwallet;
-      const address = (await wallet.connect()).address;
-
-      const signer = {
-        signTransaction: async (psbt: InstanceType<typeof Psbt>) => {
-          const signedPsbt = await wallet.signPsbt(psbt.toHex(), {
-            from: address,
-            type: "list",
-          });
-
-          return Psbt.fromHex(signedPsbt);
-        },
-        getAddress: async () => Promise.resolve(address),
-      };
-
-      const toolbox = await getUtxoToolbox(Chain.Bitcoin, { signer });
-
-      return { ...toolbox, address };
-    })
-    .with(Chain.Cosmos, async () => {
-      if (!(window.okxwallet && "keplr" in window.okxwallet)) {
-        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Cosmos });
-      }
-      const { keplr: wallet } = window.okxwallet;
-
-      await wallet.enable(ChainId.Cosmos);
-      const accounts = await wallet.getOfflineSignerOnlyAmino(ChainId.Cosmos).getAccounts();
-      if (!accounts?.[0]) throw new SwapKitError("wallet_okx_no_accounts", { chain: Chain.Cosmos });
-
-      const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
-      const [{ address }] = accounts;
-      const toolbox = getCosmosToolbox(Chain.Cosmos);
-
-      return { ...toolbox, address, transfer: cosmosTransfer(address) };
-    })
-    .with(Chain.Near, async () => {
-      if (!(window.okxwallet && "near" in window.okxwallet)) {
-        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Near });
-      }
-
-      const { createNearSignerFromProvider } = await import("../helpers/near");
-      const { getNearToolbox } = await import("@swapkit/toolboxes/near");
-
-      const provider = window.okxwallet.near;
-      const signer = await createNearSignerFromProvider(provider, "OKX");
-      const accountId = await signer.getAddress();
-      const toolbox = await getNearToolbox({ signer });
-
-      return { ...toolbox, address: accountId };
-    })
-    .with(Chain.Tron, async () => {
-      if (!(window.okxwallet && "tronLink" in window.okxwallet)) {
-        throw new SwapKitError("wallet_okx_not_found", { chain: Chain.Tron });
-      }
-
-      const { createTronToolbox } = await import("@swapkit/toolboxes/tron");
-
-      const tronLink = window.okxwallet.tronLink;
-
-      // Request account access
-      const accounts = await tronLink.request({ method: "tron_requestAccounts" });
-      if (!accounts || accounts.length === 0) {
-        throw new SwapKitError("wallet_okx_no_accounts", { chain: Chain.Tron });
-      }
-
-      const address = tronLink.tronWeb.defaultAddress.base58;
-
-      const signer: TronSigner = {
-        getAddress: async () => address,
-        signTransaction: async (transaction: TronTransaction) => {
-          return await tronLink.tronWeb.trx.sign(transaction);
-        },
-      };
-
-      const toolbox = await createTronToolbox({ signer });
-
-      return { ...toolbox, address };
-    })
-    .otherwise(() => {
-      throw new SwapKitError("wallet_okx_chain_not_supported", { chain });
-    });
-}

package/src/okx/index.ts

@@ -1,43 +0,0 @@
-import { Chain, WalletOption, createWallet, filterSupportedChains } from "@swapkit/helpers";
-
-import { getWalletSupportedChains } from "../utils";
-import { getWalletMethods } from "./helpers";
-
-export const okxWallet = createWallet({
-  name: "connectOkx",
-  walletType: WalletOption.OKX,
-  supportedChains: [
-    Chain.Arbitrum,
-    Chain.Aurora,
-    Chain.Avalanche,
-    Chain.Base,
-    Chain.Berachain,
-    Chain.BinanceSmartChain,
-    Chain.Bitcoin,
-    Chain.Cosmos,
-    Chain.Ethereum,
-    Chain.Gnosis,
-    Chain.Near,
-    Chain.Optimism,
-    Chain.Polygon,
-    Chain.Tron,
-  ],
-  connect: ({ addChain, supportedChains, walletType }) =>
-    async function connectOkx(chains: Chain[]) {
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const walletMethods = await getWalletMethods(chain);
-
-          const address = (await walletMethods.getAddress()) || "";
-
-          addChain({ ...walletMethods, address, chain, walletType });
-        }),
-      );
-
-      return true;
-    },
-});
-
-export const OKX_SUPPORTED_CHAINS = getWalletSupportedChains(okxWallet);

package/src/okx/types.ts

@@ -1,117 +0,0 @@
-import type { StdSignDoc } from "@cosmjs/amino";
-
-export enum BroadcastMode {
-  /** Return after tx commit */
-  Block = "block",
-  /** Return after CheckTx */
-  Sync = "sync",
-  /** Return right away */
-  Async = "async",
-}
-
-export interface Coin {
-  readonly denom: string;
-  readonly amount: string;
-}
-
-export interface StdFee {
-  readonly amount: readonly Coin[];
-  readonly gas: string;
-  readonly payer?: string;
-  readonly granter?: string;
-  readonly feePayer?: string;
-}
-
-export interface Msg {
-  readonly type: string;
-  readonly value: any;
-}
-
-export interface PubKey {
-  readonly type: string;
-  readonly value: string;
-}
-
-export interface StdSignature {
-  readonly pub_key: PubKey;
-  readonly signature: string;
-}
-
-export interface StdTx {
-  readonly msg: readonly Msg[];
-  readonly fee: StdFee;
-  readonly signatures: readonly StdSignature[];
-  readonly memo: string | undefined;
-}
-
-export interface AminoSignResponse {
-  readonly signed: StdSignDoc;
-  readonly signature: StdSignature;
-}
-
-export interface SignDoc {
-  /**
-   * body_bytes is protobuf serialization of a TxBody that matches the
-   * representation in TxRaw.
-   */
-  bodyBytes: Uint8Array;
-  /**
-   * auth_info_bytes is a protobuf serialization of an AuthInfo that matches the
-   * representation in TxRaw.
-   */
-  authInfoBytes: Uint8Array;
-  /**
-   * chain_id is the unique identifier of the chain this transaction targets.
-   * It prevents signed transactions from being used on another chain by an
-   * attacker
-   */
-  chainId: string;
-  /** account_number is the account number of the account in state */
-  accountNumber: any;
-}
-
-/**
- * This is the same as Algo from @cosmjs/launchpad but those might diverge in the future.
- */
-export type Algo = "secp256k1" | "ed25519" | "sr25519";
-
-/**
- * This is the same as AccountData from @cosmjs/launchpad but those might diverge in the future.
- */
-export interface AccountData {
-  /** A printable address (typically bech32 encoded) */
-  readonly address: string;
-  readonly algo: Algo;
-  readonly pubkey: Uint8Array;
-}
-
-export interface DirectSignResponse {
-  /**
-   * The sign doc that was signed.
-   * This may be different from the input signDoc when the signer modifies it as part of the signing process.
-   */
-  readonly signed: SignDoc;
-  readonly signature: StdSignature;
-}
-
-export interface OfflineDirectSigner {
-  readonly getAccounts: () => Promise<readonly AccountData[]>;
-  readonly signDirect: (signerAddress: string, signDoc: SignDoc) => Promise<DirectSignResponse>;
-}
-
-export interface OfflineAminoSigner {
-  /**
-   * Get AccountData array from wallet. Rejects if not enabled.
-   */
-  readonly getAccounts: () => Promise<readonly AccountData[]>;
-  /**
-   * Request signature from whichever key corresponds to provided bech32-encoded address. Rejects if not enabled.
-   *
-   * The signer implementation may offer the user the ability to override parts of the signDoc. It must
-   * return the doc that was signed in the response.
-   *
-   * @param signerAddress The address of the account that should sign the transaction
-   * @param signDoc The content that should be signed
-   */
-  readonly signAmino: (signerAddress: string, signDoc: StdSignDoc) => Promise<AminoSignResponse>;
-}

package/src/onekey/evmSigner.ts

@@ -1,133 +0,0 @@
-import type { Chain, DerivationPathArray } from "@swapkit/helpers";
-import { SwapKitError, WalletOption } from "@swapkit/helpers";
-import type { JsonRpcProvider, Provider, Signer, TypedDataDomain, TypedDataField } from "ethers";
-
-type OneKeyEVMSignerParams = {
-  chain: Chain;
-  derivationPath: DerivationPathArray;
-  provider: Provider | JsonRpcProvider;
-};
-
-export async function getEVMSigner({ chain, derivationPath, provider }: OneKeyEVMSignerParams) {
-  const { AbstractSigner, BrowserProvider } = await import("ethers");
-
-  class OneKeySigner extends AbstractSigner {
-    address: string;
-    chain: Chain;
-    derivationPath: DerivationPathArray;
-    readonly provider: Provider | JsonRpcProvider;
-
-    constructor({ chain, derivationPath, provider }: OneKeyEVMSignerParams) {
-      super(provider);
-
-      this.address = "";
-      this.chain = chain;
-      this.derivationPath = derivationPath;
-      this.provider = provider;
-    }
-
-    connect(provider: null | Provider): Signer {
-      if (!provider) {
-        throw new SwapKitError({
-          errorKey: "wallet_provider_not_found",
-          info: { wallet: WalletOption.ONEKEY, chain: this.chain },
-        });
-      }
-
-      return new OneKeySigner({
-        chain: this.chain,
-        derivationPath: this.derivationPath,
-        provider,
-      });
-    }
-
-    signTypedData(
-      domain: TypedDataDomain,
-      types: Record<string, TypedDataField[]>,
-      value: Record<string, any>,
-    ): Promise<string> {
-      if (!window.$onekey?.ethereum) {
-        throw new SwapKitError({
-          errorKey: "wallet_onekey_not_found",
-          info: { chain: this.chain },
-        });
-      }
-
-      return this.getAddress().then(async (_address) => {
-        try {
-          const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
-          return signer.signTypedData(domain, types, value);
-        } catch (error) {
-          throw new SwapKitError({
-            errorKey: "core_wallet_sign_message_not_supported",
-            info: { wallet: WalletOption.ONEKEY, error },
-          });
-        }
-      });
-    }
-
-    getAddress = async () => {
-      if (this.address) return this.address;
-
-      if (!window.$onekey?.ethereum) {
-        throw new SwapKitError({
-          errorKey: "wallet_onekey_not_found",
-          info: { chain: this.chain },
-        });
-      }
-
-      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
-      this.address = await signer.getAddress();
-      return this.address;
-    };
-
-    signMessage = async (message: string) => {
-      if (!window.$onekey?.ethereum) {
-        throw new SwapKitError({
-          errorKey: "wallet_onekey_not_found",
-          info: { chain: this.chain },
-        });
-      }
-
-      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
-      return signer.signMessage(message);
-    };
-
-    signTransaction = async (transaction: any) => {
-      if (!window.$onekey?.ethereum) {
-        throw new SwapKitError({
-          errorKey: "wallet_onekey_not_found",
-          info: { chain: this.chain },
-        });
-      }
-
-      const signer = await new BrowserProvider(window.$onekey.ethereum).getSigner();
-      const { to, value, gasLimit, gasPrice, data, maxFeePerGas, maxPriorityFeePerGas } =
-        transaction;
-
-      if (!to) throw new SwapKitError("toolbox_evm_no_to_address");
-      if (!gasLimit) throw new SwapKitError("toolbox_evm_no_gas_price");
-
-      const tx: any = {
-        to,
-        data,
-        gasLimit,
-      };
-
-      if (value) {
-        tx.value = value;
-      }
-
-      if (maxFeePerGas && maxPriorityFeePerGas) {
-        tx.maxFeePerGas = maxFeePerGas;
-        tx.maxPriorityFeePerGas = maxPriorityFeePerGas;
-      } else if (gasPrice) {
-        tx.gasPrice = gasPrice;
-      }
-
-      return signer.signTransaction(tx);
-    };
-  }
-
-  return new OneKeySigner({ chain, derivationPath, provider });
-}