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

package/src/exodus/index.ts

@@ -1,179 +0,0 @@
-import type { Wallet } from "@passkeys/core";
-import {
-  Chain,
-  EVMChains,
-  SwapKitError,
-  WalletOption,
-  createWallet,
-  filterSupportedChains,
-  prepareNetworkSwitch,
-  switchEVMWalletNetwork,
-} from "@swapkit/helpers";
-import { Psbt } from "bitcoinjs-lib";
-import type { BrowserProvider, Eip1193Provider } from "ethers";
-import {
-  AddressPurpose,
-  BitcoinNetworkType,
-  type BitcoinProvider,
-  type GetAddressOptions,
-  type GetAddressResponse,
-  type SignTransactionOptions,
-  getAddress,
-  signTransaction as satsSignTransaction,
-} from "sats-connect";
-import { getWalletSupportedChains } from "../utils";
-
-async function getWalletMethods({
-  walletProvider,
-  provider,
-  chain,
-}: {
-  walletProvider?: Eip1193Provider;
-  provider: BrowserProvider | BitcoinProvider;
-  chain: Chain;
-}) {
-  switch (chain) {
-    case Chain.Bitcoin: {
-      const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
-
-      let address = "";
-
-      const getProvider: () => Promise<BitcoinProvider | undefined> = () =>
-        new Promise((res) => res(provider as BitcoinProvider));
-
-      const getAddressOptions: GetAddressOptions = {
-        getProvider,
-        payload: {
-          purposes: [AddressPurpose.Payment],
-          message: "Address for receiving and sending payments",
-          network: { type: BitcoinNetworkType.Mainnet },
-        },
-        onFinish: (response: GetAddressResponse) => {
-          if (!response.addresses[0]) throw new SwapKitError("wallet_exodus_no_address");
-          address = response.addresses[0].address;
-        },
-        onCancel: () => {
-          throw new SwapKitError("wallet_exodus_request_canceled");
-        },
-      };
-
-      // TODO: Towan - probably not needed ?
-      await getAddress(getAddressOptions);
-
-      async function signTransaction(psbt: Psbt) {
-        let signedPsbt: Psbt | undefined;
-        const signPsbtOptions: SignTransactionOptions = {
-          getProvider,
-          payload: {
-            message: "Sign transaction",
-            network: {
-              type: BitcoinNetworkType.Mainnet,
-            },
-            psbtBase64: psbt.toBase64(),
-            broadcast: false,
-            inputsToSign: [
-              { address: address, signingIndexes: psbt.txInputs.map((_, index) => index) },
-            ],
-          },
-          onFinish: (response) => {
-            signedPsbt = Psbt.fromBase64(response.psbtBase64);
-          },
-          onCancel: () => {
-            throw new SwapKitError("wallet_exodus_signature_canceled");
-          },
-        };
-
-        await satsSignTransaction(signPsbtOptions);
-        if (!signedPsbt) throw new SwapKitError("wallet_exodus_sign_transaction_error");
-        return signedPsbt;
-      }
-
-      const signer = {
-        signTransaction,
-        getAddress: () => Promise.resolve(address),
-      };
-      const toolbox = await getUtxoToolbox(chain, { signer });
-
-      return { ...toolbox, address };
-    }
-    case Chain.Arbitrum:
-    case Chain.Aurora:
-    case Chain.Avalanche:
-    case Chain.Base:
-    case Chain.BinanceSmartChain:
-    case Chain.Ethereum:
-    case Chain.Optimism:
-    case Chain.Polygon: {
-      if (!walletProvider) throw new SwapKitError("wallet_exodus_not_found");
-      const { getProvider, getEvmToolbox } = await import("@swapkit/toolboxes/evm");
-
-      const jsonRpcProvider = await getProvider(chain);
-      const browserProvider = provider as BrowserProvider;
-
-      await browserProvider.send("eth_requestAccounts", []);
-
-      const signer = await browserProvider.getSigner();
-      const address = await signer.getAddress();
-      const toolbox = await getEvmToolbox(chain, { provider: jsonRpcProvider, signer });
-
-      try {
-        if (chain !== Chain.Ethereum) {
-          const networkParams = toolbox.getNetworkParams();
-          await switchEVMWalletNetwork(browserProvider, chain, networkParams);
-        }
-      } catch (_error) {
-        throw new SwapKitError("wallet_exodus_failed_to_switch_network", { chain });
-      }
-
-      return { ...prepareNetworkSwitch({ toolbox, chain, provider: browserProvider }), address };
-    }
-    default:
-      throw new SwapKitError("wallet_exodus_chain_not_supported", { chain });
-  }
-}
-
-export const exodusWallet = createWallet({
-  name: "connectExodusWallet",
-  walletType: WalletOption.EXODUS,
-  supportedChains: [...EVMChains, Chain.Bitcoin],
-  connect: ({ addChain, walletType, supportedChains }) =>
-    async function connectExodusWallet(chains: Chain[], wallet: Wallet) {
-      if (!wallet) throw new SwapKitError("wallet_exodus_instance_missing");
-      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
-      const { BrowserProvider } = await import("ethers");
-
-      const { providers } = wallet;
-
-      await Promise.all(
-        filteredChains.map(async (chain) => {
-          const provider =
-            chain === Chain.Bitcoin
-              ? providers.bitcoin
-              : new BrowserProvider(providers.ethereum, "any");
-
-          const { address, ...walletMethods } = await getWalletMethods({
-            chain,
-            provider,
-            walletProvider: providers.ethereum,
-          });
-
-          const disconnect = () =>
-            provider.send("wallet_revokePermissions", [{ eth_accounts: {} }]);
-
-          addChain({
-            ...walletMethods,
-            disconnect,
-            chain,
-            address,
-            walletType: WalletOption.EXODUS,
-          });
-        }),
-      );
-
-      return true;
-    },
-});
-
-export const EXODUS_SUPPORTED_CHAINS = getWalletSupportedChains(exodusWallet);
-export * from "@passkeys/react";
-export * from "@passkeys/core";

package/src/helpers/near-browser-provider.d.ts

@@ -1,286 +0,0 @@
-/**
- * NEAR Browser Wallet Provider Interface Definitions
- *
- * This file contains the standard TypeScript interface definitions for NEAR browser wallet providers
- * that inject themselves into the window object (e.g., OKX, XDEFI/CTRL, etc.)
- *
- * Based on:
- * - NEAR Protocol wallet-selector library
- * - Common patterns from OKX, XDEFI/CTRL, and other NEAR wallet implementations
- * - NEAR API JS types
- */
-
-import type { PublicKey } from "near-api-js/lib/utils";
-
-/**
- * Transaction action types supported by NEAR
- */
-export interface NearAction {
-  type: "FunctionCall" | "Transfer" | "Stake" | "AddKey" | "DeleteKey" | "DeleteAccount";
-  params?: {
-    methodName?: string;
-    args?: object;
-    gas?: string;
-    deposit?: string;
-    publicKey?: string;
-    beneficiaryId?: string;
-  };
-}
-
-/**
- * Transaction structure for NEAR
- */
-export interface NearTransaction {
-  receiverId: string;
-  actions: NearAction[];
-  // Optional fields
-  signerId?: string;
-  publicKey?: string;
-  nonce?: number;
-  recentBlockHash?: string;
-}
-
-/**
- * Message signing parameters
- */
-export interface NearSignMessageParams {
-  message: string;
-  recipient: string;
-  nonce: Buffer | Uint8Array;
-  callbackUrl?: string;
-  state?: string;
-}
-
-/**
- * Signed message response
- */
-export interface NearSignedMessage {
-  accountId: string;
-  publicKey: string;
-  signature: string;
-  // Optional callback data
-  callbackUrl?: string;
-  state?: string;
-}
-
-/**
- * Sign-in request parameters
- */
-export interface NearSignInParams {
-  contractId?: string;
-  methodNames?: string[];
-  // Success and failure URLs for browser wallets
-  successUrl?: string;
-  failureUrl?: string;
-}
-
-/**
- * Account information
- */
-export interface NearAccount {
-  accountId: string;
-  publicKey?: string;
-}
-
-/**
- * Access key information
- */
-export interface NearAccessKey {
-  publicKey: PublicKey;
-  accessKey: {
-    nonce: number;
-    permission:
-      | "FullAccess"
-      | {
-          FunctionCall: {
-            allowance?: string;
-            receiverId: string;
-            methodNames: string[];
-          };
-        };
-  };
-}
-
-/**
- * Transaction execution result
- */
-export interface NearFinalExecutionOutcome {
-  status: object;
-  transaction: object;
-  transaction_outcome: object;
-  receipts_outcome: object[];
-}
-
-/**
- * Standard NEAR browser wallet provider interface
- *
- * This interface represents the common API surface that NEAR browser wallets
- * expose when they inject themselves into the window object.
- */
-export interface NearBrowserWalletProvider {
-  // Connection Management
-  /**
-   * Request connection to the wallet
-   * Returns array of account IDs that were connected
-   */
-  connect(): Promise<string[]>;
-
-  /**
-   * Alternative connection method used by some wallets
-   */
-  request?(params: { method: "connect"; params?: any }): Promise<string[]>;
-
-  /**
-   * Disconnect from the wallet
-   */
-  disconnect(): Promise<void>;
-
-  /**
-   * Sign out from the wallet (some wallets use this instead of disconnect)
-   */
-  signOut?(): void;
-
-  // Account Management
-  /**
-   * Check if user is signed in
-   */
-  isSignedIn?(): boolean;
-
-  /**
-   * Get the current account ID
-   */
-  getAccountId(): string | Promise<string>;
-
-  /**
-   * Get list of accounts (some wallets support multiple accounts)
-   */
-  getAccounts?(): Promise<NearAccount[]>;
-
-  /**
-   * Get the public key for the current account
-   */
-  getPublicKey?(): Promise<string>;
-
-  // Legacy sign-in methods (used by some wallets)
-  /**
-   * Request sign in (legacy method)
-   */
-  requestSignIn?(params: NearSignInParams): Promise<NearAccount>;
-
-  // Signing Operations
-  /**
-   * Sign a message
-   */
-  signMessage(params: NearSignMessageParams): Promise<NearSignedMessage>;
-
-  /**
-   * Sign and send a single transaction
-   */
-  signAndSendTransaction(params: {
-    receiverId: string;
-    actions: NearAction[];
-    // Optional parameters
-    signerId?: string;
-    publicKey?: string;
-    nonce?: number;
-    recentBlockHash?: string;
-  }): Promise<NearFinalExecutionOutcome>;
-
-  /**
-   * Sign and send multiple transactions
-   */
-  signAndSendTransactions(params: {
-    transactions: NearTransaction[];
-  }): Promise<NearFinalExecutionOutcome[]>;
-
-  /**
-   * Request signing of transactions (alternative method used by some wallets)
-   */
-  requestSignTransactions?(params: {
-    transactions: NearTransaction[];
-  }): Promise<any>;
-
-  // Verification
-  /**
-   * Verify ownership of an account
-   */
-  verifyOwner?(params: {
-    message: string;
-    // Additional parameters may vary by wallet
-  }): Promise<{
-    accountId: string;
-    publicKey: string;
-    signature: string;
-    // Additional fields may be returned
-  }>;
-
-  // Network Information
-  /**
-   * Get the current network (mainnet, testnet, etc.)
-   */
-  getNetwork?(): string | Promise<string>;
-
-  /**
-   * Check if wallet is connected to mainnet
-   */
-  isMainnet?(): boolean;
-
-  // Wallet Metadata
-  /**
-   * Wallet name or identifier
-   */
-  name?: string;
-
-  /**
-   * Wallet version
-   */
-  version?: string;
-
-  /**
-   * Check if this is a specific wallet (used for wallet detection)
-   */
-  isOKX?: boolean;
-  isXDEFI?: boolean;
-  isCTRL?: boolean;
-
-  // Event Handling (not all wallets support events)
-  on?(event: "accountsChanged" | "networkChanged" | "disconnect", handler: Function): void;
-  off?(event: string, handler: Function): void;
-  removeListener?(event: string, handler: Function): void;
-}
-
-/**
- * Extended window interface for NEAR wallets
- */
-declare global {
-  interface Window {
-    // Generic NEAR provider (if wallet uses this pattern)
-    near?: NearBrowserWalletProvider;
-
-    // Specific wallet providers
-    okxwallet?: {
-      near: NearBrowserWalletProvider;
-    };
-
-    xfi?: {
-      near: NearBrowserWalletProvider;
-    };
-
-    // Add other wallet-specific providers as needed
-  }
-}
-
-/**
- * Helper type for wallet detection
- */
-export type NearWalletType = "okx" | "xdefi" | "ctrl" | "generic";
-
-/**
- * Configuration for NEAR network
- */
-export interface NearNetworkConfig {
-  networkId: "mainnet" | "testnet" | "betanet";
-  nodeUrl: string;
-  walletUrl?: string;
-  helperUrl?: string;
-}

package/src/helpers/near.ts

@@ -1,206 +0,0 @@
-//TBD @towan to be moved somewhere else
-import { SwapKitError } from "@swapkit/helpers";
-import type { NearSigner } from "@swapkit/toolboxes/near";
-import type { Account } from "near-api-js";
-import {
-  type Action,
-  type Signature,
-  SignedTransaction,
-  type Transaction,
-} from "near-api-js/lib/transaction";
-
-/**
- * NEAR Browser Wallet Provider Interface
- * Common interface implemented by browser extension wallets
- */
-export interface NearBrowserWalletProvider {
-  // Connection methods
-  connect(params?: { contractId?: string; methodNames?: string[] }): Promise<
-    Account[] | { accountId: string }
-  >;
-  disconnect?(): Promise<void>;
-  signOut?(): Promise<void>; // Alternative to disconnect
-
-  // Account methods
-  getAccountId(): string | Promise<string>;
-  getAccounts?(): Promise<Account[]>;
-  isSignedIn(): boolean;
-  getPublicKey?(): Promise<string>;
-
-  // Signing methods
-  signMessage?(params: any): Promise<any>;
-  signAndSendTransaction(params: {
-    receiverId: string;
-    actions: Action[];
-    signerId?: string;
-  }): Promise<any>;
-  signAndSendTransactions?(params: {
-    transactions: Transaction[];
-  }): Promise<any[]>;
-
-  // Optional utility methods
-  request<T>(params: { method: string; params?: any }): Promise<T>;
-  verifyOwner?(params: {
-    message: string;
-    callbackUrl?: string;
-  }): Promise<any>;
-  getNetwork?(): Promise<{ networkId: string; nodeUrl: string }>;
-
-  // Event handlers (optional)
-  on?(event: string, handler: Function): void;
-  off?(event: string, handler: Function): void;
-}
-
-/**
- * Helper to create a NEAR signer from browser extension providers
- */
-export async function createNearSignerFromProvider(
-  provider: NearBrowserWalletProvider,
-  walletName: string,
-) {
-  const isConnected = provider.isSignedIn ? provider.isSignedIn() : false;
-  if (!isConnected) {
-    await provider.connect({ contractId: "", methodNames: [] });
-  }
-
-  const signer = {
-    ...provider,
-    async getPublicKey() {
-      // Most browser wallets expose public key through message signing
-      const { utils } = await import("near-api-js");
-
-      if (provider.getPublicKey) {
-        const pubKey = await provider.getPublicKey();
-        return utils.PublicKey.from(pubKey);
-      }
-
-      if (!provider.signMessage) {
-        throw new SwapKitError("wallet_ledger_method_not_supported", {
-          wallet: walletName,
-          method: "getPublicKey",
-        });
-      }
-
-      // Most browser wallets don't expose public key directly
-      // Return a dummy public key
-      const { PublicKey } = await import("near-api-js/lib/utils");
-      // Create a dummy ed25519 public key
-      const dummyKeyData = Buffer.alloc(32);
-      const dummyKey = `ed25519:${Buffer.from(dummyKeyData).toString("base64")}`;
-      return PublicKey.from(dummyKey);
-    },
-
-    async signNep413Message(
-      message: string,
-      _accountId: string,
-      recipient: string,
-      nonce: Uint8Array,
-      callbackUrl?: string,
-    ) {
-      if (!provider.signMessage) {
-        throw new SwapKitError("wallet_ledger_method_not_supported", {
-          wallet: walletName,
-          method: "signNep413Message",
-        });
-      }
-
-      // We know signMessage exists because we checked above
-      const result = await (
-        provider as Required<Pick<NearBrowserWalletProvider, "signMessage">>
-      ).signMessage({
-        message,
-        recipient,
-        nonce: Buffer.from(nonce),
-        callbackUrl,
-      });
-
-      return result;
-    },
-
-    async signTransaction(transaction: Transaction) {
-      if (!provider.request) {
-        throw new SwapKitError("wallet_near_method_not_supported", {
-          wallet: walletName,
-          method: "request",
-        });
-      }
-
-      // Browser wallets typically sign and send in one operation
-      // This is a limitation of browser wallet APIs
-      const result = await provider.request<{ signatures: Signature }>({
-        method: "near_signTransactions",
-        params: {
-          transactions: [transaction], // must be Array type
-        },
-      });
-
-      const signedTransaction = new SignedTransaction({
-        transaction,
-        signature: result.signatures,
-      });
-
-      return [result.signatures.data, signedTransaction] as [
-        Uint8Array<ArrayBufferLike>,
-        SignedTransaction,
-      ];
-    },
-
-    signDelegateAction(_delegateAction: any) {
-      // Most browser wallets don't support delegate actions yet
-      return Promise.reject(
-        new SwapKitError("wallet_ledger_method_not_supported", {
-          wallet: walletName,
-          method: "signDelegateAction",
-        }),
-      );
-    },
-
-    async getAddress() {
-      if (provider.getAccountId) {
-        return provider.getAccountId();
-      }
-
-      if (provider.isSignedIn && !provider.isSignedIn()) {
-        // Try connect method for wallets that don't have requestSignIn
-        const result = await provider.connect();
-        if (Array.isArray(result) && result.length > 0 && result[0]) {
-          return typeof result[0] === "string" ? result[0] : result[0].accountId;
-        }
-        throw new SwapKitError("wallet_connection_rejected_by_user", {
-          wallet: walletName,
-        });
-      }
-
-      throw new SwapKitError("wallet_connection_rejected_by_user", {
-        wallet: walletName,
-      });
-    },
-  };
-
-  return signer as NearSigner;
-}
-
-/**
- * Detect if a wallet provider supports NEAR
- */
-export function detectNearProvider(
-  window: any,
-  providerPath: string,
-): NearBrowserWalletProvider | null {
-  const parts = providerPath.split(".");
-  let provider = window;
-
-  for (const part of parts) {
-    provider = provider?.[part];
-    if (!provider) return null;
-  }
-
-  return provider;
-}
-
-/**
- * Get NEAR chain ID for WalletConnect
- */
-export function getNearChainId(isTestnet: boolean): string {
-  return isTestnet ? "near:testnet" : "near:mainnet";
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from "./utils";
-export * from "./types";