@vue-solana/core 0.4.1 → 0.5.0

package/dist/shared/core.8V8PLE-S.cjs

@@ -0,0 +1,237 @@
+'use strict';
+
+const features = require('@wallet-standard/features');
+const walletStandardFeatures = require('@solana/wallet-standard-features');
+const web3Compat = require('@solana/web3-compat');
+const bs58 = require('bs58');
+const app = require('@wallet-standard/app');
+
+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 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);
+}
+
+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 {
+    platform: walletInfo.platform,
+    source: walletInfo.source,
+    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
+        }))
+      );
+      if (results.length !== transactions.length) {
+        throw new Error(
+          `Solana wallet returned ${results.length} signed transactions for ${transactions.length} requested transactions`
+        );
+      }
+      return results.map((result, index) => {
+        if (!result) {
+          throw new Error("Solana wallet did not return a signed transaction");
+        }
+        return 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 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;
+}
+
+const SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME = "Mobile Wallet Adapter";
+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 createSolanaWalletInfo(wallet) {
+  const isMobileWallet = wallet.name === SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME;
+  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;
+}
+
+exports.SOLANA_CHAINS = SOLANA_CHAINS;
+exports.SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME = SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME;
+exports.adaptSolanaStandardWallet = adaptSolanaStandardWallet;
+exports.getRegisteredSolanaWallets = getRegisteredSolanaWallets;
+exports.getSolanaChain = getSolanaChain;
+exports.isSolanaStandardWallet = isSolanaStandardWallet;
+exports.subscribeSolanaWallets = subscribeSolanaWallets;

package/dist/shared/core.D7olTUN_.mjs

@@ -0,0 +1,225 @@
+import { StandardEvents, StandardDisconnect, StandardConnect } from '@wallet-standard/features';
+import { SolanaSignAndSendTransaction, SolanaSignTransaction } from '@solana/wallet-standard-features';
+import { Transaction, VersionedTransaction, PublicKey } from '@solana/web3-compat';
+import bs58 from 'bs58';
+import { getWallets } from '@wallet-standard/app';
+
+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 hasSignTransaction(wallet) {
+  return SolanaSignTransaction in wallet.features;
+}
+function hasSignAndSendTransaction(wallet) {
+  return SolanaSignAndSendTransaction in wallet.features;
+}
+
+function serializeTransaction(transaction) {
+  if (transaction instanceof Transaction) {
+    return transaction.serialize({ requireAllSignatures: false, verifySignatures: false });
+  }
+  return transaction.serialize();
+}
+function deserializeTransaction(source, bytes) {
+  if (source instanceof Transaction) {
+    return Transaction.from(bytes);
+  }
+  return VersionedTransaction.deserialize(bytes);
+}
+
+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[StandardEvents];
+  eventsFeature?.on("change", (properties) => {
+    if (properties.accounts) {
+      accounts = properties.accounts;
+      account = allowAccountUpdates && !manuallyDisconnected ? getSolanaAccount(accounts, options.chain) : void 0;
+      options.onChange?.();
+    }
+  });
+  return {
+    platform: walletInfo.platform,
+    source: walletInfo.source,
+    get publicKey() {
+      return account ? new 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[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[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[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[SolanaSignTransaction].signTransaction(
+        ...transactions.map((transaction) => ({
+          account: activeAccount,
+          transaction: serializeTransaction(transaction),
+          chain: options.chain
+        }))
+      );
+      if (results.length !== transactions.length) {
+        throw new Error(
+          `Solana wallet returned ${results.length} signed transactions for ${transactions.length} requested transactions`
+        );
+      }
+      return results.map((result, index) => {
+        if (!result) {
+          throw new Error("Solana wallet did not return a signed transaction");
+        }
+        return deserializeTransaction(transactions[index], result.signedTransaction);
+      });
+    } : void 0,
+    signAndSendTransaction: hasSignAndSendTransaction(wallet) ? async (transaction, sendOptions) => {
+      const activeAccount = getActiveAccount(account);
+      const [result] = await wallet.features[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.encode(result.signature) };
+    } : 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;
+}
+
+const SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME = "Mobile Wallet Adapter";
+function isSolanaStandardWallet(wallet) {
+  return StandardConnect in wallet.features && StandardDisconnect in wallet.features && wallet.chains.some((chain) => SOLANA_CHAINS.includes(chain));
+}
+function getRegisteredSolanaWallets() {
+  if (typeof window === "undefined") {
+    return [];
+  }
+  return getWallets().get().filter(isSolanaStandardWallet).map(createSolanaWalletInfo);
+}
+function subscribeSolanaWallets(listener) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const wallets = getWallets();
+  const offRegister = wallets.on("register", listener);
+  const offUnregister = wallets.on("unregister", listener);
+  return () => {
+    offRegister();
+    offUnregister();
+  };
+}
+function createSolanaWalletInfo(wallet) {
+  const isMobileWallet = wallet.name === SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME;
+  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;
+}
+
+export { SOLANA_CHAINS as S, SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME as a, adaptSolanaStandardWallet as b, getSolanaChain as c, getRegisteredSolanaWallets as g, isSolanaStandardWallet as i, subscribeSolanaWallets as s };