@vue-solana/core 0.2.1 → 0.3.0

package/dist/rpc.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+const web3Compat = require('@solana/web3-compat');
+const clusters = require('./clusters.cjs');
+
+function createSolanaConnection(config = {}) {
+  const cluster = config.cluster ?? clusters.DEFAULT_CLUSTER;
+  const endpoint = config.endpoint ?? clusters.getClusterEndpoint(cluster);
+  const wsEndpoint = config.wsEndpoint ?? (config.endpoint ? clusters.getWebSocketEndpoint(endpoint) : clusters.getClusterWebSocketEndpoint(cluster));
+  return new web3Compat.Connection(endpoint, {
+    commitment: config.commitment,
+    wsEndpoint
+  });
+}
+function createSolanaContext(config = {}) {
+  const cluster = config.cluster ?? clusters.DEFAULT_CLUSTER;
+  const endpoint = config.endpoint ?? clusters.getClusterEndpoint(cluster);
+  const wsEndpoint = config.wsEndpoint ?? (config.endpoint ? clusters.getWebSocketEndpoint(endpoint) : clusters.getClusterWebSocketEndpoint(cluster));
+  return {
+    cluster,
+    endpoint,
+    wsEndpoint,
+    connection: new web3Compat.Connection(endpoint, {
+      commitment: config.commitment,
+      wsEndpoint
+    })
+  };
+}
+
+exports.createSolanaConnection = createSolanaConnection;
+exports.createSolanaContext = createSolanaContext;

package/dist/rpc.d.cts

@@ -0,0 +1,7 @@
+import { Connection } from '@solana/web3-compat';
+import { SolanaConfig, SolanaContext } from './types.cjs';
+
+declare function createSolanaConnection(config?: SolanaConfig): Connection;
+declare function createSolanaContext(config?: SolanaConfig): SolanaContext;
+
+export { createSolanaConnection, createSolanaContext };

package/dist/rpc.d.mts

@@ -0,0 +1,7 @@
+import { Connection } from '@solana/web3-compat';
+import { SolanaConfig, SolanaContext } from './types.mjs';
+
+declare function createSolanaConnection(config?: SolanaConfig): Connection;
+declare function createSolanaContext(config?: SolanaConfig): SolanaContext;
+
+export { createSolanaConnection, createSolanaContext };

package/dist/rpc.d.ts

@@ -0,0 +1,7 @@
+import { Connection } from '@solana/web3-compat';
+import { SolanaConfig, SolanaContext } from './types.js';
+
+declare function createSolanaConnection(config?: SolanaConfig): Connection;
+declare function createSolanaContext(config?: SolanaConfig): SolanaContext;
+
+export { createSolanaConnection, createSolanaContext };

package/dist/rpc.mjs

@@ -0,0 +1,28 @@
+import { Connection } from '@solana/web3-compat';
+import { DEFAULT_CLUSTER, getClusterEndpoint, getWebSocketEndpoint, getClusterWebSocketEndpoint } from './clusters.mjs';
+
+function createSolanaConnection(config = {}) {
+  const cluster = config.cluster ?? DEFAULT_CLUSTER;
+  const endpoint = config.endpoint ?? getClusterEndpoint(cluster);
+  const wsEndpoint = config.wsEndpoint ?? (config.endpoint ? getWebSocketEndpoint(endpoint) : getClusterWebSocketEndpoint(cluster));
+  return new Connection(endpoint, {
+    commitment: config.commitment,
+    wsEndpoint
+  });
+}
+function createSolanaContext(config = {}) {
+  const cluster = config.cluster ?? DEFAULT_CLUSTER;
+  const endpoint = config.endpoint ?? getClusterEndpoint(cluster);
+  const wsEndpoint = config.wsEndpoint ?? (config.endpoint ? getWebSocketEndpoint(endpoint) : getClusterWebSocketEndpoint(cluster));
+  return {
+    cluster,
+    endpoint,
+    wsEndpoint,
+    connection: new Connection(endpoint, {
+      commitment: config.commitment,
+      wsEndpoint
+    })
+  };
+}
+
+export { createSolanaConnection, createSolanaContext };

package/dist/transaction.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+const wallet = require('./wallet.cjs');
+
+async function signAndSendTransaction(connection, wallet$1, transaction, options) {
+  wallet.assertWalletConnected(wallet$1);
+  if (wallet$1.signAndSendTransaction) {
+    const result = await wallet$1.signAndSendTransaction(transaction, options);
+    return result.signature;
+  }
+  wallet.assertWalletCanSign(wallet$1);
+  const signedTransaction = await wallet$1.signTransaction(transaction);
+  const rawTransaction = signedTransaction.serialize();
+  return connection.sendRawTransaction(rawTransaction, options);
+}
+
+exports.signAndSendTransaction = signAndSendTransaction;

package/dist/transaction.d.cts

@@ -0,0 +1,6 @@
+import { Connection, TransactionSignature } from '@solana/web3-compat';
+import { SolanaWallet, SolanaTransaction, SendTransactionOptions } from './types.cjs';
+
+declare function signAndSendTransaction(connection: Connection, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<TransactionSignature>;
+
+export { signAndSendTransaction };

package/dist/transaction.d.mts

@@ -0,0 +1,6 @@
+import { Connection, TransactionSignature } from '@solana/web3-compat';
+import { SolanaWallet, SolanaTransaction, SendTransactionOptions } from './types.mjs';
+
+declare function signAndSendTransaction(connection: Connection, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<TransactionSignature>;
+
+export { signAndSendTransaction };

package/dist/transaction.d.ts

@@ -0,0 +1,6 @@
+import { Connection, TransactionSignature } from '@solana/web3-compat';
+import { SolanaWallet, SolanaTransaction, SendTransactionOptions } from './types.js';
+
+declare function signAndSendTransaction(connection: Connection, wallet: SolanaWallet, transaction: SolanaTransaction, options?: SendTransactionOptions): Promise<TransactionSignature>;
+
+export { signAndSendTransaction };

package/dist/transaction.mjs

@@ -0,0 +1,15 @@
+import { assertWalletConnected, assertWalletCanSign } from './wallet.mjs';
+
+async function signAndSendTransaction(connection, wallet, transaction, options) {
+  assertWalletConnected(wallet);
+  if (wallet.signAndSendTransaction) {
+    const result = await wallet.signAndSendTransaction(transaction, options);
+    return result.signature;
+  }
+  assertWalletCanSign(wallet);
+  const signedTransaction = await wallet.signTransaction(transaction);
+  const rawTransaction = signedTransaction.serialize();
+  return connection.sendRawTransaction(rawTransaction, options);
+}
+
+export { signAndSendTransaction };

package/dist/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types.d.cts

@@ -0,0 +1,53 @@
+import { SendOptions, Commitment, Connection, Transaction, VersionedTransaction, PublicKey, TransactionSignature } from '@solana/web3-compat';
+
+type SolanaCluster = "mainnet-beta" | "testnet" | "devnet" | "localnet";
+type SolanaChain = "solana:mainnet" | "solana:testnet" | "solana:devnet" | "solana:localnet";
+interface SolanaConfig {
+    cluster?: SolanaCluster;
+    endpoint?: string;
+    wsEndpoint?: string;
+    commitment?: Commitment;
+    autoConnect?: boolean;
+}
+interface SolanaContext {
+    cluster: SolanaCluster;
+    endpoint: string;
+    wsEndpoint: string;
+    connection: Connection;
+}
+type SolanaTransaction = Transaction | VersionedTransaction;
+interface SolanaWallet {
+    publicKey: PublicKey | null;
+    connected: boolean;
+    connecting?: boolean;
+    disconnecting?: boolean;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    signTransaction?: <T extends SolanaTransaction>(transaction: T) => Promise<T>;
+    signAllTransactions?: <T extends SolanaTransaction>(transactions: T[]) => Promise<T[]>;
+    signAndSendTransaction?: (transaction: SolanaTransaction, options?: SendOptions) => Promise<{
+        signature: TransactionSignature;
+    }>;
+}
+interface SolanaWalletInfo {
+    name: string;
+    icon: string;
+    chains: readonly string[];
+    platform?: "browser" | "mobile" | "desktop";
+    source?: "wallet-standard" | "mobile-wallet-adapter" | "deep-link" | "protocol-link";
+    appUrl?: string;
+    installUrl?: string;
+    accounts: readonly {
+        address: string;
+        publicKey: Uint8Array;
+        chains: readonly string[];
+        label?: string;
+        icon?: string;
+    }[];
+    wallet: unknown;
+}
+interface SendTransactionOptions extends SendOptions {
+    skipPreflight?: boolean;
+}
+
+export type { SendTransactionOptions, SolanaChain, SolanaCluster, SolanaConfig, SolanaContext, SolanaTransaction, SolanaWallet, SolanaWalletInfo };

package/dist/types.d.mts

@@ -0,0 +1,53 @@
+import { SendOptions, Commitment, Connection, Transaction, VersionedTransaction, PublicKey, TransactionSignature } from '@solana/web3-compat';
+
+type SolanaCluster = "mainnet-beta" | "testnet" | "devnet" | "localnet";
+type SolanaChain = "solana:mainnet" | "solana:testnet" | "solana:devnet" | "solana:localnet";
+interface SolanaConfig {
+    cluster?: SolanaCluster;
+    endpoint?: string;
+    wsEndpoint?: string;
+    commitment?: Commitment;
+    autoConnect?: boolean;
+}
+interface SolanaContext {
+    cluster: SolanaCluster;
+    endpoint: string;
+    wsEndpoint: string;
+    connection: Connection;
+}
+type SolanaTransaction = Transaction | VersionedTransaction;
+interface SolanaWallet {
+    publicKey: PublicKey | null;
+    connected: boolean;
+    connecting?: boolean;
+    disconnecting?: boolean;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    signTransaction?: <T extends SolanaTransaction>(transaction: T) => Promise<T>;
+    signAllTransactions?: <T extends SolanaTransaction>(transactions: T[]) => Promise<T[]>;
+    signAndSendTransaction?: (transaction: SolanaTransaction, options?: SendOptions) => Promise<{
+        signature: TransactionSignature;
+    }>;
+}
+interface SolanaWalletInfo {
+    name: string;
+    icon: string;
+    chains: readonly string[];
+    platform?: "browser" | "mobile" | "desktop";
+    source?: "wallet-standard" | "mobile-wallet-adapter" | "deep-link" | "protocol-link";
+    appUrl?: string;
+    installUrl?: string;
+    accounts: readonly {
+        address: string;
+        publicKey: Uint8Array;
+        chains: readonly string[];
+        label?: string;
+        icon?: string;
+    }[];
+    wallet: unknown;
+}
+interface SendTransactionOptions extends SendOptions {
+    skipPreflight?: boolean;
+}
+
+export type { SendTransactionOptions, SolanaChain, SolanaCluster, SolanaConfig, SolanaContext, SolanaTransaction, SolanaWallet, SolanaWalletInfo };

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+import { SendOptions, Commitment, Connection, Transaction, VersionedTransaction, PublicKey, TransactionSignature } from '@solana/web3-compat';
+
+type SolanaCluster = "mainnet-beta" | "testnet" | "devnet" | "localnet";
+type SolanaChain = "solana:mainnet" | "solana:testnet" | "solana:devnet" | "solana:localnet";
+interface SolanaConfig {
+    cluster?: SolanaCluster;
+    endpoint?: string;
+    wsEndpoint?: string;
+    commitment?: Commitment;
+    autoConnect?: boolean;
+}
+interface SolanaContext {
+    cluster: SolanaCluster;
+    endpoint: string;
+    wsEndpoint: string;
+    connection: Connection;
+}
+type SolanaTransaction = Transaction | VersionedTransaction;
+interface SolanaWallet {
+    publicKey: PublicKey | null;
+    connected: boolean;
+    connecting?: boolean;
+    disconnecting?: boolean;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    signTransaction?: <T extends SolanaTransaction>(transaction: T) => Promise<T>;
+    signAllTransactions?: <T extends SolanaTransaction>(transactions: T[]) => Promise<T[]>;
+    signAndSendTransaction?: (transaction: SolanaTransaction, options?: SendOptions) => Promise<{
+        signature: TransactionSignature;
+    }>;
+}
+interface SolanaWalletInfo {
+    name: string;
+    icon: string;
+    chains: readonly string[];
+    platform?: "browser" | "mobile" | "desktop";
+    source?: "wallet-standard" | "mobile-wallet-adapter" | "deep-link" | "protocol-link";
+    appUrl?: string;
+    installUrl?: string;
+    accounts: readonly {
+        address: string;
+        publicKey: Uint8Array;
+        chains: readonly string[];
+        label?: string;
+        icon?: string;
+    }[];
+    wallet: unknown;
+}
+interface SendTransactionOptions extends SendOptions {
+    skipPreflight?: boolean;
+}
+
+export type { SendTransactionOptions, SolanaChain, SolanaCluster, SolanaConfig, SolanaContext, SolanaTransaction, SolanaWallet, SolanaWalletInfo };

package/dist/types.mjs

@@ -0,0 +1 @@
+

package/dist/wallet-standard.cjs

@@ -0,0 +1,221 @@
+'use strict';
+
+const app = require('@wallet-standard/app');
+const walletStandardMobile = require('@solana-mobile/wallet-standard-mobile');
+const features = require('@wallet-standard/features');
+const walletStandardFeatures = require('@solana/wallet-standard-features');
+const web3Compat = require('@solana/web3-compat');
+const bs58 = require('bs58');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const bs58__default = /*#__PURE__*/_interopDefaultCompat(bs58);
+
+const SOLANA_CHAINS = [
+  "solana:mainnet",
+  "solana:testnet",
+  "solana:devnet",
+  "solana:localnet"
+];
+function getSolanaChain(cluster) {
+  if (cluster === "mainnet-beta") {
+    return "solana:mainnet";
+  }
+  return `solana:${cluster}`;
+}
+function isSolanaStandardWallet(wallet) {
+  return features.StandardConnect in wallet.features && features.StandardDisconnect in wallet.features && wallet.chains.some((chain) => SOLANA_CHAINS.includes(chain));
+}
+function getRegisteredSolanaWallets() {
+  if (typeof window === "undefined") {
+    return [];
+  }
+  return app.getWallets().get().filter(isSolanaStandardWallet).map(createSolanaWalletInfo);
+}
+function subscribeSolanaWallets(listener) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const wallets = app.getWallets();
+  const offRegister = wallets.on("register", listener);
+  const offUnregister = wallets.on("unregister", listener);
+  return () => {
+    offRegister();
+    offUnregister();
+  };
+}
+function adaptSolanaStandardWallet(walletInfo, options = {}) {
+  const wallet = walletInfo.wallet;
+  let accounts = wallet.accounts;
+  let account = options.account;
+  let allowAccountUpdates = Boolean(options.account);
+  let connecting = false;
+  let disconnecting = false;
+  let manuallyDisconnected = false;
+  const eventsFeature = wallet.features[features.StandardEvents];
+  eventsFeature?.on("change", (properties) => {
+    if (properties.accounts) {
+      accounts = properties.accounts;
+      account = allowAccountUpdates && !manuallyDisconnected ? getSolanaAccount(accounts, options.chain) : void 0;
+      options.onChange?.();
+    }
+  });
+  return {
+    get publicKey() {
+      return account ? new web3Compat.PublicKey(account.publicKey) : null;
+    },
+    get connected() {
+      return Boolean(account);
+    },
+    get connecting() {
+      return connecting;
+    },
+    get disconnecting() {
+      return disconnecting;
+    },
+    async connect() {
+      connecting = true;
+      manuallyDisconnected = false;
+      options.onChange?.();
+      try {
+        const feature = wallet.features[features.StandardConnect];
+        const result = await feature.connect();
+        accounts = result.accounts;
+        allowAccountUpdates = true;
+        account = getSolanaAccount(accounts, options.chain);
+        if (!account) {
+          throw new Error("Solana wallet did not authorize a Solana account");
+        }
+      } finally {
+        connecting = false;
+        options.onChange?.();
+      }
+    },
+    async disconnect() {
+      const feature = wallet.features[features.StandardDisconnect];
+      disconnecting = true;
+      manuallyDisconnected = true;
+      allowAccountUpdates = false;
+      account = void 0;
+      options.onChange?.();
+      try {
+        await feature.disconnect();
+        accounts = [];
+        account = void 0;
+      } catch (error) {
+        manuallyDisconnected = false;
+        allowAccountUpdates = true;
+        account = getSolanaAccount(accounts, options.chain);
+        throw error;
+      } finally {
+        disconnecting = false;
+        options.onChange?.();
+      }
+    },
+    signTransaction: hasSignTransaction(wallet) ? async (transaction) => {
+      const activeAccount = getActiveAccount(account);
+      const [result] = await wallet.features[walletStandardFeatures.SolanaSignTransaction].signTransaction({
+        account: activeAccount,
+        transaction: serializeTransaction(transaction),
+        chain: options.chain
+      });
+      if (!result) {
+        throw new Error("Solana wallet did not return a signed transaction");
+      }
+      return deserializeTransaction(transaction, result.signedTransaction);
+    } : void 0,
+    signAllTransactions: hasSignTransaction(wallet) ? async (transactions) => {
+      const activeAccount = getActiveAccount(account);
+      const results = await wallet.features[walletStandardFeatures.SolanaSignTransaction].signTransaction(
+        ...transactions.map((transaction) => ({
+          account: activeAccount,
+          transaction: serializeTransaction(transaction),
+          chain: options.chain
+        }))
+      );
+      return results.map(
+        (result, index) => deserializeTransaction(transactions[index], result.signedTransaction)
+      );
+    } : void 0,
+    signAndSendTransaction: hasSignAndSendTransaction(wallet) ? async (transaction, sendOptions) => {
+      const activeAccount = getActiveAccount(account);
+      const [result] = await wallet.features[walletStandardFeatures.SolanaSignAndSendTransaction].signAndSendTransaction({
+        account: activeAccount,
+        transaction: serializeTransaction(transaction),
+        chain: options.chain ?? getSolanaAccountChain(activeAccount),
+        options: sendOptions
+      });
+      if (!result) {
+        throw new Error("Solana wallet did not return a transaction signature");
+      }
+      return { signature: bs58__default.encode(result.signature) };
+    } : void 0
+  };
+}
+function createSolanaWalletInfo(wallet) {
+  const isMobileWallet = wallet.name === walletStandardMobile.SolanaMobileWalletAdapterWalletName;
+  return {
+    name: wallet.name,
+    icon: wallet.icon,
+    chains: wallet.chains,
+    platform: isMobileWallet ? "mobile" : "browser",
+    source: isMobileWallet ? "mobile-wallet-adapter" : "wallet-standard",
+    appUrl: getWalletUrl(wallet),
+    accounts: wallet.accounts.map((account) => ({
+      address: account.address,
+      publicKey: Uint8Array.from(account.publicKey),
+      chains: account.chains,
+      label: account.label,
+      icon: account.icon
+    })),
+    wallet
+  };
+}
+function getWalletUrl(wallet) {
+  return "url" in wallet && typeof wallet.url === "string" ? wallet.url : void 0;
+}
+function getSolanaAccount(accounts, chain) {
+  return accounts.find((account) => account.chains.some((accountChain) => accountChain === chain)) ?? accounts.find(
+    (account) => account.chains.some((accountChain) => SOLANA_CHAINS.includes(accountChain))
+  );
+}
+function getActiveAccount(account) {
+  if (!account) {
+    throw new Error("Solana wallet is not connected");
+  }
+  return account;
+}
+function getSolanaAccountChain(account) {
+  const chain = account.chains.find(
+    (accountChain) => SOLANA_CHAINS.includes(accountChain)
+  );
+  if (!chain) {
+    throw new Error("Solana wallet account does not support a Solana chain");
+  }
+  return chain;
+}
+function hasSignTransaction(wallet) {
+  return walletStandardFeatures.SolanaSignTransaction in wallet.features;
+}
+function hasSignAndSendTransaction(wallet) {
+  return walletStandardFeatures.SolanaSignAndSendTransaction in wallet.features;
+}
+function serializeTransaction(transaction) {
+  if (transaction instanceof web3Compat.Transaction) {
+    return transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
+  }
+  return transaction.serialize();
+}
+function deserializeTransaction(source, bytes) {
+  if (source instanceof web3Compat.Transaction) {
+    return web3Compat.Transaction.from(bytes);
+  }
+  return web3Compat.VersionedTransaction.deserialize(bytes);
+}
+
+exports.adaptSolanaStandardWallet = adaptSolanaStandardWallet;
+exports.getRegisteredSolanaWallets = getRegisteredSolanaWallets;
+exports.getSolanaChain = getSolanaChain;
+exports.isSolanaStandardWallet = isSolanaStandardWallet;
+exports.subscribeSolanaWallets = subscribeSolanaWallets;

package/dist/wallet-standard.d.cts

@@ -0,0 +1,17 @@
+import { WalletAccount, Wallet } from '@wallet-standard/base';
+import { SolanaChain, SolanaWalletInfo, SolanaWallet, SolanaCluster } from './types.cjs';
+import '@solana/web3-compat';
+
+interface AdaptSolanaWalletOptions {
+    chain?: SolanaChain;
+    account?: WalletAccount;
+    onChange?: () => void;
+}
+declare function getSolanaChain(cluster: SolanaCluster): SolanaChain;
+declare function isSolanaStandardWallet(wallet: Wallet): boolean;
+declare function getRegisteredSolanaWallets(): SolanaWalletInfo[];
+declare function subscribeSolanaWallets(listener: () => void): () => void;
+declare function adaptSolanaStandardWallet(walletInfo: SolanaWalletInfo, options?: AdaptSolanaWalletOptions): SolanaWallet;
+
+export { adaptSolanaStandardWallet, getRegisteredSolanaWallets, getSolanaChain, isSolanaStandardWallet, subscribeSolanaWallets };
+export type { AdaptSolanaWalletOptions };

package/dist/wallet-standard.d.mts

@@ -0,0 +1,17 @@
+import { WalletAccount, Wallet } from '@wallet-standard/base';
+import { SolanaChain, SolanaWalletInfo, SolanaWallet, SolanaCluster } from './types.mjs';
+import '@solana/web3-compat';
+
+interface AdaptSolanaWalletOptions {
+    chain?: SolanaChain;
+    account?: WalletAccount;
+    onChange?: () => void;
+}
+declare function getSolanaChain(cluster: SolanaCluster): SolanaChain;
+declare function isSolanaStandardWallet(wallet: Wallet): boolean;
+declare function getRegisteredSolanaWallets(): SolanaWalletInfo[];
+declare function subscribeSolanaWallets(listener: () => void): () => void;
+declare function adaptSolanaStandardWallet(walletInfo: SolanaWalletInfo, options?: AdaptSolanaWalletOptions): SolanaWallet;
+
+export { adaptSolanaStandardWallet, getRegisteredSolanaWallets, getSolanaChain, isSolanaStandardWallet, subscribeSolanaWallets };
+export type { AdaptSolanaWalletOptions };

package/dist/wallet-standard.d.ts

@@ -0,0 +1,17 @@
+import { WalletAccount, Wallet } from '@wallet-standard/base';
+import { SolanaChain, SolanaWalletInfo, SolanaWallet, SolanaCluster } from './types.js';
+import '@solana/web3-compat';
+
+interface AdaptSolanaWalletOptions {
+    chain?: SolanaChain;
+    account?: WalletAccount;
+    onChange?: () => void;
+}
+declare function getSolanaChain(cluster: SolanaCluster): SolanaChain;
+declare function isSolanaStandardWallet(wallet: Wallet): boolean;
+declare function getRegisteredSolanaWallets(): SolanaWalletInfo[];
+declare function subscribeSolanaWallets(listener: () => void): () => void;
+declare function adaptSolanaStandardWallet(walletInfo: SolanaWalletInfo, options?: AdaptSolanaWalletOptions): SolanaWallet;
+
+export { adaptSolanaStandardWallet, getRegisteredSolanaWallets, getSolanaChain, isSolanaStandardWallet, subscribeSolanaWallets };
+export type { AdaptSolanaWalletOptions };