@vue-solana/core 0.3.3 → 0.4.1

package/README.md

@@ -112,17 +112,17 @@ const wallet: SolanaWallet = {
 };
 ```
 
-Browser extension wallets discovered through the Solana Wallet Standard are adapted into `SolanaWallet`. Android Mobile Wallet Adapter is registered through `@solana-mobile/wallet-standard-mobile` and then adapted through the same Wallet Standard adapter on supported Android Chrome clients. You can also provide a custom object that implements `SolanaWallet` for tests or custom adapters.
+Browser extension wallets discovered through the Solana Wallet Standard are adapted into `SolanaWallet`. Android Mobile Wallet Adapter is registered through `@solana-mobile/wallet-standard-mobile` and then adapted through the same Wallet Standard adapter on supported Android Chrome clients. iOS browser wallet entries for Phantom, Solflare, and Backpack are adapted through wallet-specific universal links. You can also provide a custom object that implements `SolanaWallet` for tests or custom adapters.
 
 Current wallet support:
 
 - Browser extension wallets through Wallet Standard packages.
 - Android native mobile wallets through `@solana-mobile/wallet-standard-mobile` on Android Chrome and Chrome PWAs.
+- iOS browser wallets for Phantom, Solflare, and Backpack through wallet-specific universal links.
 - Manual/custom wallet objects that implement `SolanaWallet`.
 
 Planned but not supported yet:
 
-- iOS browser wallets through wallet-specific universal link or deep link adapters.
 - Desktop native app wallets through wallet-specific protocol links or future native Wallet Standard registration.
 
 ## Examples

package/dist/index.cjs

@@ -1,17 +1,19 @@
 'use strict';
 
 const clusters = require('./clusters.cjs');
+const iosWallet = require('./ios-wallet.cjs');
 const mobileWallet = require('./mobile-wallet.cjs');
 const rpc = require('./rpc.cjs');
 const transaction = require('./transaction.cjs');
 const wallet = require('./wallet.cjs');
 const walletStandard = require('./wallet-standard.cjs');
-require('@solana-mobile/wallet-standard-mobile');
 require('@solana/web3-compat');
+require('bs58');
+require('tweetnacl');
+require('@solana-mobile/wallet-standard-mobile');
 require('@wallet-standard/app');
 require('@wallet-standard/features');
 require('@solana/wallet-standard-features');
-require('bs58');
 
 
 
@@ -19,6 +21,14 @@ exports.DEFAULT_CLUSTER = clusters.DEFAULT_CLUSTER;
 exports.getClusterEndpoint = clusters.getClusterEndpoint;
 exports.getClusterWebSocketEndpoint = clusters.getClusterWebSocketEndpoint;
 exports.getWebSocketEndpoint = clusters.getWebSocketEndpoint;
+exports.adaptSolanaIosWallet = iosWallet.adaptSolanaIosWallet;
+exports.getDefaultIosWalletAppIdentity = iosWallet.getDefaultIosWalletAppIdentity;
+exports.getDefaultIosWalletRedirectUrl = iosWallet.getDefaultIosWalletRedirectUrl;
+exports.getSolanaIosWallets = iosWallet.getSolanaIosWallets;
+exports.handleSolanaIosWalletCallback = iosWallet.handleSolanaIosWalletCallback;
+exports.isIosBrowser = iosWallet.isIosBrowser;
+exports.isSolanaIosBrowserWalletSupported = iosWallet.isSolanaIosBrowserWalletSupported;
+exports.isSolanaIosWalletInfo = iosWallet.isSolanaIosWalletInfo;
 exports.getDefaultMobileWalletAppIdentity = mobileWallet.getDefaultMobileWalletAppIdentity;
 exports.isSolanaMobileWalletSupported = mobileWallet.isSolanaMobileWalletSupported;
 exports.registerSolanaMobileWallet = mobileWallet.registerSolanaMobileWallet;

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 export { DEFAULT_CLUSTER, getClusterEndpoint, getClusterWebSocketEndpoint, getWebSocketEndpoint } from './clusters.cjs';
+export { AdaptSolanaIosWalletOptions, GetSolanaIosWalletsOptions, SolanaIosWalletAppIdentity, adaptSolanaIosWallet, getDefaultIosWalletAppIdentity, getDefaultIosWalletRedirectUrl, getSolanaIosWallets, handleSolanaIosWalletCallback, isIosBrowser, isSolanaIosBrowserWalletSupported, isSolanaIosWalletInfo } from './ios-wallet.cjs';
 export { RegisterSolanaMobileWalletOptions, SolanaMobileWalletAppIdentity, getDefaultMobileWalletAppIdentity, isSolanaMobileWalletSupported, registerSolanaMobileWallet } from './mobile-wallet.cjs';
 export { createSolanaConnection, createSolanaContext } from './rpc.cjs';
 export { signAndSendTransaction } from './transaction.cjs';

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 export { DEFAULT_CLUSTER, getClusterEndpoint, getClusterWebSocketEndpoint, getWebSocketEndpoint } from './clusters.mjs';
+export { AdaptSolanaIosWalletOptions, GetSolanaIosWalletsOptions, SolanaIosWalletAppIdentity, adaptSolanaIosWallet, getDefaultIosWalletAppIdentity, getDefaultIosWalletRedirectUrl, getSolanaIosWallets, handleSolanaIosWalletCallback, isIosBrowser, isSolanaIosBrowserWalletSupported, isSolanaIosWalletInfo } from './ios-wallet.mjs';
 export { RegisterSolanaMobileWalletOptions, SolanaMobileWalletAppIdentity, getDefaultMobileWalletAppIdentity, isSolanaMobileWalletSupported, registerSolanaMobileWallet } from './mobile-wallet.mjs';
 export { createSolanaConnection, createSolanaContext } from './rpc.mjs';
 export { signAndSendTransaction } from './transaction.mjs';

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { DEFAULT_CLUSTER, getClusterEndpoint, getClusterWebSocketEndpoint, getWebSocketEndpoint } from './clusters.js';
+export { AdaptSolanaIosWalletOptions, GetSolanaIosWalletsOptions, SolanaIosWalletAppIdentity, adaptSolanaIosWallet, getDefaultIosWalletAppIdentity, getDefaultIosWalletRedirectUrl, getSolanaIosWallets, handleSolanaIosWalletCallback, isIosBrowser, isSolanaIosBrowserWalletSupported, isSolanaIosWalletInfo } from './ios-wallet.js';
 export { RegisterSolanaMobileWalletOptions, SolanaMobileWalletAppIdentity, getDefaultMobileWalletAppIdentity, isSolanaMobileWalletSupported, registerSolanaMobileWallet } from './mobile-wallet.js';
 export { createSolanaConnection, createSolanaContext } from './rpc.js';
 export { signAndSendTransaction } from './transaction.js';

package/dist/index.mjs

@@ -1,12 +1,14 @@
 export { DEFAULT_CLUSTER, getClusterEndpoint, getClusterWebSocketEndpoint, getWebSocketEndpoint } from './clusters.mjs';
+export { adaptSolanaIosWallet, getDefaultIosWalletAppIdentity, getDefaultIosWalletRedirectUrl, getSolanaIosWallets, handleSolanaIosWalletCallback, isIosBrowser, isSolanaIosBrowserWalletSupported, isSolanaIosWalletInfo } from './ios-wallet.mjs';
 export { getDefaultMobileWalletAppIdentity, isSolanaMobileWalletSupported, registerSolanaMobileWallet } from './mobile-wallet.mjs';
 export { createSolanaConnection, createSolanaContext } from './rpc.mjs';
 export { signAndSendTransaction } from './transaction.mjs';
 export { assertWalletCanSign, assertWalletConnected, isWalletConnected } from './wallet.mjs';
 export { SOLANA_MOBILE_WALLET_ADAPTER_WALLET_NAME, adaptSolanaStandardWallet, getRegisteredSolanaWallets, getSolanaChain, isSolanaStandardWallet, subscribeSolanaWallets } from './wallet-standard.mjs';
-import '@solana-mobile/wallet-standard-mobile';
 import '@solana/web3-compat';
+import 'bs58';
+import 'tweetnacl';
+import '@solana-mobile/wallet-standard-mobile';
 import '@wallet-standard/app';
 import '@wallet-standard/features';
 import '@solana/wallet-standard-features';
-import 'bs58';

package/dist/ios-wallet.cjs

@@ -0,0 +1,543 @@
+'use strict';
+
+const web3Compat = require('@solana/web3-compat');
+const bs58 = require('bs58');
+const naclModule = require('tweetnacl');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const bs58__default = /*#__PURE__*/_interopDefaultCompat(bs58);
+const naclModule__namespace = /*#__PURE__*/_interopNamespaceCompat(naclModule);
+
+const nacl = resolveTweetNaCl();
+function resolveTweetNaCl() {
+  const moduleDefault = naclModule__namespace.default;
+  const globalNacl = globalThis.nacl;
+  return "box" in naclModule__namespace ? naclModule__namespace : moduleDefault ?? globalNacl;
+}
+const DEFAULT_IOS_WALLET_CHAINS = ["solana:mainnet", "solana:devnet"];
+const PENDING_REQUEST_KEY = "vue-solana:ios-wallet:pending";
+const SESSION_PREFIX = "vue-solana:ios-wallet:session:";
+const CALLBACK_PARAMS = /* @__PURE__ */ new Set([
+  "data",
+  "nonce",
+  "errorCode",
+  "errorMessage",
+  "phantom_encryption_public_key",
+  "solflare_encryption_public_key",
+  "wallet_encryption_public_key"
+]);
+const IOS_WALLETS = [
+  {
+    id: "phantom",
+    name: "Phantom",
+    icon: "https://phantom.app/img/phantom-logo.svg",
+    appUrl: "https://phantom.app",
+    installUrl: "https://phantom.app/download",
+    encryptionPublicKeyParam: "phantom_encryption_public_key",
+    connectUrl: "https://phantom.app/ul/v1/connect",
+    signTransactionUrl: "https://phantom.app/ul/v1/signTransaction",
+    signAllTransactionsUrl: "https://phantom.app/ul/v1/signAllTransactions"
+  },
+  {
+    id: "solflare",
+    name: "Solflare",
+    icon: "https://solflare.com/favicon.ico",
+    appUrl: "https://solflare.com",
+    installUrl: "https://solflare.com/download",
+    encryptionPublicKeyParam: "solflare_encryption_public_key",
+    connectUrl: "https://solflare.com/ul/v1/connect",
+    signTransactionUrl: "https://solflare.com/ul/v1/signTransaction",
+    signAllTransactionsUrl: "https://solflare.com/ul/v1/signAllTransactions",
+    signAndSendTransactionUrl: "https://solflare.com/ul/v1/signAndSendTransaction"
+  },
+  {
+    id: "backpack",
+    name: "Backpack",
+    icon: "https://backpack.app/favicon.ico",
+    appUrl: "https://backpack.app",
+    installUrl: "https://backpack.app/download",
+    encryptionPublicKeyParam: "wallet_encryption_public_key",
+    connectUrl: "https://backpack.app/ul/v1/connect",
+    signTransactionUrl: "https://backpack.app/ul/v1/signTransaction",
+    signAllTransactionsUrl: "https://backpack.app/ul/v1/signAllTransactions",
+    signAndSendTransactionUrl: "https://backpack.app/ul/v1/signAndSendTransaction"
+  }
+];
+function getSolanaIosWallets(options = {}) {
+  if (!isSolanaIosBrowserWalletSupported()) {
+    return [];
+  }
+  const chains = options.chains?.length ? options.chains : DEFAULT_IOS_WALLET_CHAINS;
+  const callbackUrl = options.redirectUrl ?? getDefaultIosWalletRedirectUrl();
+  return IOS_WALLETS.map((wallet) => ({
+    name: wallet.name,
+    icon: wallet.icon,
+    chains,
+    platform: "mobile",
+    source: "deep-link",
+    appUrl: wallet.appUrl,
+    installUrl: wallet.installUrl,
+    callbackUrl,
+    capabilities: {
+      connect: true,
+      signTransaction: Boolean(wallet.signTransactionUrl),
+      signAllTransactions: Boolean(wallet.signAllTransactionsUrl),
+      signAndSendTransaction: Boolean(wallet.signAndSendTransactionUrl)
+    },
+    accounts: getStoredIosWalletAccount(wallet.id, chains),
+    wallet
+  }));
+}
+function adaptSolanaIosWallet(walletInfo, options = {}) {
+  const definition = getIosWalletDefinition(walletInfo);
+  let connecting = false;
+  let disconnecting = false;
+  let session = getStoredSession(definition.id);
+  function refreshSession() {
+    session = getStoredSession(definition.id);
+    options.onChange?.();
+  }
+  return {
+    get publicKey() {
+      return session?.publicKey ? new web3Compat.PublicKey(session.publicKey) : null;
+    },
+    get connected() {
+      return Boolean(session?.publicKey && session.session);
+    },
+    get connecting() {
+      return connecting;
+    },
+    get disconnecting() {
+      return disconnecting;
+    },
+    async connect() {
+      const callback = handleSolanaIosWalletCallback({ clearUrl: true });
+      if (callback?.walletId === definition.id) {
+        refreshSession();
+        return;
+      }
+      connecting = true;
+      options.onChange?.();
+      try {
+        launchConnect(definition, options);
+        await waitForRedirect();
+      } finally {
+        connecting = false;
+        options.onChange?.();
+      }
+    },
+    async disconnect() {
+      disconnecting = true;
+      options.onChange?.();
+      try {
+        removeStoredSession(definition.id);
+        refreshSession();
+      } finally {
+        disconnecting = false;
+        options.onChange?.();
+      }
+    },
+    signTransaction: definition.signTransactionUrl ? async (transaction) => {
+      const signedTransaction = await launchSignTransaction(definition, transaction, options);
+      return deserializeTransaction(transaction, signedTransaction);
+    } : void 0,
+    signAllTransactions: definition.signAllTransactionsUrl ? async (transactions) => {
+      const signedTransactions = await launchSignAllTransactions(
+        definition,
+        transactions,
+        options
+      );
+      return signedTransactions.map(
+        (transaction, index) => deserializeTransaction(transactions[index], transaction)
+      );
+    } : void 0,
+    signAndSendTransaction: definition.signAndSendTransactionUrl ? async (transaction, sendOptions) => launchSignAndSendTransaction(definition, transaction, sendOptions, options) : void 0
+  };
+}
+function handleSolanaIosWalletCallback(options = {}) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const url = new URL(window.location.href);
+  if (!hasIosWalletCallbackParams(url)) {
+    return null;
+  }
+  const errorCode = url.searchParams.get("errorCode");
+  const errorMessage = url.searchParams.get("errorMessage");
+  if (errorCode || errorMessage) {
+    clearPendingRequest();
+    cleanCallbackUrl(url, options.clearUrl);
+    throw new Error(errorMessage || `iOS wallet request failed: ${errorCode}`);
+  }
+  const pending = getPendingRequest();
+  if (!pending) {
+    cleanCallbackUrl(url, options.clearUrl);
+    throw new Error("Received an iOS wallet callback without a pending request");
+  }
+  const definition = getIosWalletDefinitionById(pending.walletId);
+  const walletEncryptionPublicKey = url.searchParams.get(definition.encryptionPublicKeyParam);
+  const nonce = url.searchParams.get("nonce");
+  const data = url.searchParams.get("data");
+  if (!nonce || !data) {
+    throw new Error("Received an incomplete iOS wallet callback");
+  }
+  const sharedSecret = getSharedSecret(
+    walletEncryptionPublicKey ?? getStoredSession(pending.walletId)?.walletEncryptionPublicKey,
+    pending.dappEncryptionSecretKey
+  );
+  const payload = decryptPayload(data, nonce, sharedSecret);
+  const result = createCallbackResult(pending, payload);
+  if (pending.method === "connect") {
+    if (!walletEncryptionPublicKey) {
+      throw new Error("iOS wallet connect callback did not include an encryption public key");
+    }
+    storeSession({
+      walletId: pending.walletId,
+      publicKey: getStringField(payload, "public_key"),
+      session: getStringField(payload, "session"),
+      dappEncryptionPublicKey: pending.dappEncryptionPublicKey,
+      dappEncryptionSecretKey: pending.dappEncryptionSecretKey,
+      walletEncryptionPublicKey,
+      sharedSecret: bs58__default.encode(sharedSecret)
+    });
+  }
+  clearPendingRequest();
+  cleanCallbackUrl(url, options.clearUrl);
+  return result;
+}
+function isSolanaIosWalletInfo(walletInfo) {
+  return walletInfo.source === "deep-link" && isIosWalletDefinition(walletInfo.wallet);
+}
+function isSolanaIosBrowserWalletSupported() {
+  return isIosBrowser();
+}
+function isIosBrowser() {
+  if (typeof window === "undefined" || typeof navigator === "undefined") {
+    return false;
+  }
+  const userAgent = navigator.userAgent;
+  const platform = navigator.platform;
+  const maxTouchPoints = navigator.maxTouchPoints ?? 0;
+  return /iPad|iPhone|iPod/i.test(userAgent) || platform === "MacIntel" && maxTouchPoints > 1;
+}
+function getDefaultIosWalletAppIdentity() {
+  if (typeof window === "undefined") {
+    return {
+      name: "Vue Solana App",
+      uri: "https://localhost"
+    };
+  }
+  return {
+    name: document.title || "Vue Solana App",
+    uri: window.location.origin,
+    icon: getDocumentIconUrl()
+  };
+}
+function getDefaultIosWalletRedirectUrl() {
+  if (typeof window === "undefined") {
+    return "https://localhost";
+  }
+  const url = new URL(window.location.href);
+  for (const param of CALLBACK_PARAMS) {
+    url.searchParams.delete(param);
+  }
+  return url.toString();
+}
+function launchConnect(definition, options) {
+  const keyPair = nacl.box.keyPair();
+  const pending = createPendingRequest(definition.id, "connect", keyPair, options.redirectUrl);
+  const appIdentity = options.appIdentity ?? getDefaultIosWalletAppIdentity();
+  const url = new URL(definition.connectUrl);
+  url.searchParams.set("app_url", appIdentity.uri);
+  url.searchParams.set("dapp_encryption_public_key", pending.dappEncryptionPublicKey);
+  url.searchParams.set("redirect_link", pending.redirectUrl);
+  if (options.cluster && options.cluster !== "localnet") {
+    url.searchParams.set("cluster", options.cluster);
+  }
+  storePendingRequest(pending);
+  openIosWalletUrl(url.toString());
+}
+async function launchSignTransaction(definition, transaction, options) {
+  const response = await launchEncryptedWalletRequest(definition, "signTransaction", options, {
+    transaction: bs58__default.encode(serializeTransaction(transaction))
+  });
+  if (!response.transaction) {
+    throw new Error("iOS wallet did not return a signed transaction");
+  }
+  return response.transaction;
+}
+async function launchSignAllTransactions(definition, transactions, options) {
+  const response = await launchEncryptedWalletRequest(definition, "signAllTransactions", options, {
+    transactions: transactions.map((transaction) => bs58__default.encode(serializeTransaction(transaction)))
+  });
+  if (!response.transactions) {
+    throw new Error("iOS wallet did not return signed transactions");
+  }
+  return response.transactions;
+}
+async function launchSignAndSendTransaction(definition, transaction, sendOptions, options) {
+  const response = await launchEncryptedWalletRequest(
+    definition,
+    "signAndSendTransaction",
+    options,
+    {
+      transaction: bs58__default.encode(serializeTransaction(transaction)),
+      sendOptions
+    }
+  );
+  if (!response.signature) {
+    throw new Error("iOS wallet did not return a transaction signature");
+  }
+  return { signature: response.signature };
+}
+async function launchEncryptedWalletRequest(definition, method, options, payload) {
+  const session = getStoredSession(definition.id);
+  if (!session) {
+    throw new Error("Connect the iOS wallet before signing");
+  }
+  const methodUrl = getIosWalletMethodUrl(definition, method);
+  const pending = createPendingRequest(
+    definition.id,
+    method,
+    {
+      publicKey: bs58__default.decode(session.dappEncryptionPublicKey),
+      secretKey: bs58__default.decode(session.dappEncryptionSecretKey)
+    },
+    options.redirectUrl
+  );
+  const nonce = nacl.randomBytes(nacl.box.nonceLength);
+  const encryptedPayload = encryptPayload(
+    { ...payload, session: session.session },
+    nonce,
+    bs58__default.decode(session.sharedSecret)
+  );
+  const url = new URL(methodUrl);
+  url.searchParams.set("dapp_encryption_public_key", session.dappEncryptionPublicKey);
+  url.searchParams.set("nonce", bs58__default.encode(nonce));
+  url.searchParams.set("redirect_link", pending.redirectUrl);
+  url.searchParams.set("payload", encryptedPayload);
+  storePendingRequest(pending);
+  openIosWalletUrl(url.toString());
+  return waitForRedirect();
+}
+function createPendingRequest(walletId, method, keyPair, redirectUrl) {
+  return {
+    id: createRequestId(),
+    walletId,
+    method,
+    dappEncryptionPublicKey: bs58__default.encode(keyPair.publicKey),
+    dappEncryptionSecretKey: bs58__default.encode(keyPair.secretKey),
+    redirectUrl: redirectUrl ?? getDefaultIosWalletRedirectUrl(),
+    createdAt: Date.now()
+  };
+}
+function createCallbackResult(pending, payload) {
+  if (pending.method === "connect") {
+    return {
+      walletId: pending.walletId,
+      method: pending.method,
+      publicKey: getStringField(payload, "public_key")
+    };
+  }
+  if (pending.method === "signTransaction") {
+    return {
+      walletId: pending.walletId,
+      method: pending.method,
+      transaction: bs58__default.decode(getStringField(payload, "transaction"))
+    };
+  }
+  if (pending.method === "signAllTransactions") {
+    const transactions = payload.transactions;
+    if (!Array.isArray(transactions) || transactions.some((transaction) => typeof transaction !== "string")) {
+      throw new Error("iOS wallet returned invalid signed transactions");
+    }
+    return {
+      walletId: pending.walletId,
+      method: pending.method,
+      transactions: transactions.map((transaction) => bs58__default.decode(transaction))
+    };
+  }
+  return {
+    walletId: pending.walletId,
+    method: pending.method,
+    signature: getStringField(payload, "signature")
+  };
+}
+function getIosWalletMethodUrl(definition, method) {
+  const url = definition[`${method}Url`];
+  if (!url) {
+    throw new Error(`${definition.name} does not support ${method} through iOS deeplinks`);
+  }
+  return url;
+}
+function getSharedSecret(walletEncryptionPublicKey, dappSecretKey) {
+  if (!walletEncryptionPublicKey) {
+    throw new Error("Missing iOS wallet encryption public key");
+  }
+  return nacl.box.before(bs58__default.decode(walletEncryptionPublicKey), bs58__default.decode(dappSecretKey));
+}
+function encryptPayload(payload, nonce, sharedSecret) {
+  return bs58__default.encode(nacl.box.after(encodeJson(payload), nonce, sharedSecret));
+}
+function decryptPayload(data, nonce, sharedSecret) {
+  const decrypted = nacl.box.open.after(bs58__default.decode(data), bs58__default.decode(nonce), sharedSecret);
+  if (!decrypted) {
+    throw new Error("Unable to decrypt iOS wallet callback");
+  }
+  return JSON.parse(new TextDecoder().decode(decrypted));
+}
+function encodeJson(value) {
+  return new TextEncoder().encode(JSON.stringify(value));
+}
+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 getStoredIosWalletAccount(walletId, chains) {
+  const session = getStoredSession(walletId);
+  if (!session) {
+    return [];
+  }
+  return [
+    {
+      address: session.publicKey,
+      publicKey: new web3Compat.PublicKey(session.publicKey).toBytes(),
+      chains
+    }
+  ];
+}
+function getStoredSession(walletId) {
+  const value = getStorage()?.getItem(`${SESSION_PREFIX}${walletId}`);
+  if (!value) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    removeStoredSession(walletId);
+    return null;
+  }
+}
+function storeSession(session) {
+  getStorage()?.setItem(`${SESSION_PREFIX}${session.walletId}`, JSON.stringify(session));
+}
+function removeStoredSession(walletId) {
+  getStorage()?.removeItem(`${SESSION_PREFIX}${walletId}`);
+}
+function getPendingRequest() {
+  const value = getStorage()?.getItem(PENDING_REQUEST_KEY);
+  if (!value) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    clearPendingRequest();
+    return null;
+  }
+}
+function storePendingRequest(request) {
+  getStorage()?.setItem(PENDING_REQUEST_KEY, JSON.stringify(request));
+}
+function clearPendingRequest() {
+  getStorage()?.removeItem(PENDING_REQUEST_KEY);
+}
+function getStorage() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function openIosWalletUrl(url) {
+  if (typeof window === "undefined") {
+    throw new Error("iOS wallet links are only available in browser runtimes");
+  }
+  window.location.assign(url);
+}
+function waitForRedirect() {
+  return new Promise(() => {
+  });
+}
+function hasIosWalletCallbackParams(url) {
+  for (const param of CALLBACK_PARAMS) {
+    if (url.searchParams.has(param)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cleanCallbackUrl(url, clearUrl) {
+  if (!clearUrl || typeof window === "undefined") {
+    return;
+  }
+  for (const param of CALLBACK_PARAMS) {
+    url.searchParams.delete(param);
+  }
+  window.history.replaceState(window.history.state, document.title, url.toString());
+}
+function createRequestId() {
+  return bs58__default.encode(nacl.randomBytes(16));
+}
+function getStringField(payload, field) {
+  const value = payload[field];
+  if (typeof value !== "string" || !value) {
+    throw new Error(`iOS wallet callback is missing ${field}`);
+  }
+  return value;
+}
+function getIosWalletDefinition(walletInfo) {
+  if (!isIosWalletDefinition(walletInfo.wallet)) {
+    throw new Error("Solana wallet info is not an iOS wallet");
+  }
+  return walletInfo.wallet;
+}
+function getIosWalletDefinitionById(walletId) {
+  const definition = IOS_WALLETS.find((wallet) => wallet.id === walletId);
+  if (!definition) {
+    throw new Error(`Unknown iOS wallet: ${walletId}`);
+  }
+  return definition;
+}
+function isIosWalletDefinition(value) {
+  return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && IOS_WALLETS.some((wallet) => wallet.id === value.id);
+}
+function getDocumentIconUrl() {
+  const icon = document.querySelector(
+    'link[rel="icon"], link[rel="shortcut icon"], link[rel="apple-touch-icon"]'
+  );
+  return icon?.href;
+}
+
+exports.adaptSolanaIosWallet = adaptSolanaIosWallet;
+exports.getDefaultIosWalletAppIdentity = getDefaultIosWalletAppIdentity;
+exports.getDefaultIosWalletRedirectUrl = getDefaultIosWalletRedirectUrl;
+exports.getSolanaIosWallets = getSolanaIosWallets;
+exports.handleSolanaIosWalletCallback = handleSolanaIosWalletCallback;
+exports.isIosBrowser = isIosBrowser;
+exports.isSolanaIosBrowserWalletSupported = isSolanaIosBrowserWalletSupported;
+exports.isSolanaIosWalletInfo = isSolanaIosWalletInfo;

package/dist/ios-wallet.d.cts

@@ -0,0 +1,42 @@
+import { SolanaChain, SolanaCluster, SolanaWalletInfo, SolanaWallet } from './types.cjs';
+import '@solana/web3-compat';
+
+interface SolanaIosWalletAppIdentity {
+    name: string;
+    uri: string;
+    icon?: string;
+}
+interface GetSolanaIosWalletsOptions {
+    appIdentity?: SolanaIosWalletAppIdentity;
+    redirectUrl?: string;
+    chains?: readonly SolanaChain[];
+    cluster?: SolanaCluster;
+}
+interface AdaptSolanaIosWalletOptions {
+    appIdentity?: SolanaIosWalletAppIdentity;
+    redirectUrl?: string;
+    chain?: SolanaChain;
+    cluster?: SolanaCluster;
+    onChange?: () => void;
+}
+type IosWalletMethod = "connect" | "signTransaction" | "signAllTransactions" | "signAndSendTransaction";
+declare function getSolanaIosWallets(options?: GetSolanaIosWalletsOptions): SolanaWalletInfo[];
+declare function adaptSolanaIosWallet(walletInfo: SolanaWalletInfo, options?: AdaptSolanaIosWalletOptions): SolanaWallet;
+declare function handleSolanaIosWalletCallback(options?: {
+    clearUrl?: boolean;
+}): {
+    walletId: string;
+    method: IosWalletMethod;
+    publicKey?: string;
+    signature?: string;
+    transaction?: Uint8Array;
+    transactions?: Uint8Array[];
+} | null;
+declare function isSolanaIosWalletInfo(walletInfo: SolanaWalletInfo): boolean;
+declare function isSolanaIosBrowserWalletSupported(): boolean;
+declare function isIosBrowser(): boolean;
+declare function getDefaultIosWalletAppIdentity(): SolanaIosWalletAppIdentity;
+declare function getDefaultIosWalletRedirectUrl(): string;
+
+export { adaptSolanaIosWallet, getDefaultIosWalletAppIdentity, getDefaultIosWalletRedirectUrl, getSolanaIosWallets, handleSolanaIosWalletCallback, isIosBrowser, isSolanaIosBrowserWalletSupported, isSolanaIosWalletInfo };
+export type { AdaptSolanaIosWalletOptions, GetSolanaIosWalletsOptions, SolanaIosWalletAppIdentity };

package/dist/ios-wallet.d.mts

@@ -0,0 +1,42 @@
+import { SolanaChain, SolanaCluster, SolanaWalletInfo, SolanaWallet } from './types.mjs';
+import '@solana/web3-compat';
+
+interface SolanaIosWalletAppIdentity {
+    name: string;
+    uri: string;
+    icon?: string;
+}
+interface GetSolanaIosWalletsOptions {
+    appIdentity?: SolanaIosWalletAppIdentity;
+    redirectUrl?: string;
+    chains?: readonly SolanaChain[];
+    cluster?: SolanaCluster;
+}
+interface AdaptSolanaIosWalletOptions {
+    appIdentity?: SolanaIosWalletAppIdentity;
+    redirectUrl?: string;
+    chain?: SolanaChain;
+    cluster?: SolanaCluster;
+    onChange?: () => void;
+}
+type IosWalletMethod = "connect" | "signTransaction" | "signAllTransactions" | "signAndSendTransaction";
+declare function getSolanaIosWallets(options?: GetSolanaIosWalletsOptions): SolanaWalletInfo[];
+declare function adaptSolanaIosWallet(walletInfo: SolanaWalletInfo, options?: AdaptSolanaIosWalletOptions): SolanaWallet;
+declare function handleSolanaIosWalletCallback(options?: {
+    clearUrl?: boolean;
+}): {
+    walletId: string;
+    method: IosWalletMethod;
+    publicKey?: string;
+    signature?: string;
+    transaction?: Uint8Array;
+    transactions?: Uint8Array[];
+} | null;
+declare function isSolanaIosWalletInfo(walletInfo: SolanaWalletInfo): boolean;
+declare function isSolanaIosBrowserWalletSupported(): boolean;
+declare function isIosBrowser(): boolean;
+declare function getDefaultIosWalletAppIdentity(): SolanaIosWalletAppIdentity;
+declare function getDefaultIosWalletRedirectUrl(): string;
+
+export { adaptSolanaIosWallet, getDefaultIosWalletAppIdentity, getDefaultIosWalletRedirectUrl, getSolanaIosWallets, handleSolanaIosWalletCallback, isIosBrowser, isSolanaIosBrowserWalletSupported, isSolanaIosWalletInfo };
+export type { AdaptSolanaIosWalletOptions, GetSolanaIosWalletsOptions, SolanaIosWalletAppIdentity };

package/dist/ios-wallet.d.ts

@@ -0,0 +1,42 @@
+import { SolanaChain, SolanaCluster, SolanaWalletInfo, SolanaWallet } from './types.js';
+import '@solana/web3-compat';
+
+interface SolanaIosWalletAppIdentity {
+    name: string;
+    uri: string;
+    icon?: string;
+}
+interface GetSolanaIosWalletsOptions {
+    appIdentity?: SolanaIosWalletAppIdentity;
+    redirectUrl?: string;
+    chains?: readonly SolanaChain[];
+    cluster?: SolanaCluster;
+}
+interface AdaptSolanaIosWalletOptions {
+    appIdentity?: SolanaIosWalletAppIdentity;
+    redirectUrl?: string;
+    chain?: SolanaChain;
+    cluster?: SolanaCluster;
+    onChange?: () => void;
+}
+type IosWalletMethod = "connect" | "signTransaction" | "signAllTransactions" | "signAndSendTransaction";
+declare function getSolanaIosWallets(options?: GetSolanaIosWalletsOptions): SolanaWalletInfo[];
+declare function adaptSolanaIosWallet(walletInfo: SolanaWalletInfo, options?: AdaptSolanaIosWalletOptions): SolanaWallet;
+declare function handleSolanaIosWalletCallback(options?: {
+    clearUrl?: boolean;
+}): {
+    walletId: string;
+    method: IosWalletMethod;
+    publicKey?: string;
+    signature?: string;
+    transaction?: Uint8Array;
+    transactions?: Uint8Array[];
+} | null;
+declare function isSolanaIosWalletInfo(walletInfo: SolanaWalletInfo): boolean;
+declare function isSolanaIosBrowserWalletSupported(): boolean;
+declare function isIosBrowser(): boolean;
+declare function getDefaultIosWalletAppIdentity(): SolanaIosWalletAppIdentity;
+declare function getDefaultIosWalletRedirectUrl(): string;
+
+export { adaptSolanaIosWallet, getDefaultIosWalletAppIdentity, getDefaultIosWalletRedirectUrl, getSolanaIosWallets, handleSolanaIosWalletCallback, isIosBrowser, isSolanaIosBrowserWalletSupported, isSolanaIosWalletInfo };
+export type { AdaptSolanaIosWalletOptions, GetSolanaIosWalletsOptions, SolanaIosWalletAppIdentity };

package/dist/ios-wallet.mjs

@@ -0,0 +1,517 @@
+import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3-compat';
+import bs58 from 'bs58';
+import * as naclModule from 'tweetnacl';
+
+const nacl = resolveTweetNaCl();
+function resolveTweetNaCl() {
+  const moduleDefault = naclModule.default;
+  const globalNacl = globalThis.nacl;
+  return "box" in naclModule ? naclModule : moduleDefault ?? globalNacl;
+}
+const DEFAULT_IOS_WALLET_CHAINS = ["solana:mainnet", "solana:devnet"];
+const PENDING_REQUEST_KEY = "vue-solana:ios-wallet:pending";
+const SESSION_PREFIX = "vue-solana:ios-wallet:session:";
+const CALLBACK_PARAMS = /* @__PURE__ */ new Set([
+  "data",
+  "nonce",
+  "errorCode",
+  "errorMessage",
+  "phantom_encryption_public_key",
+  "solflare_encryption_public_key",
+  "wallet_encryption_public_key"
+]);
+const IOS_WALLETS = [
+  {
+    id: "phantom",
+    name: "Phantom",
+    icon: "https://phantom.app/img/phantom-logo.svg",
+    appUrl: "https://phantom.app",
+    installUrl: "https://phantom.app/download",
+    encryptionPublicKeyParam: "phantom_encryption_public_key",
+    connectUrl: "https://phantom.app/ul/v1/connect",
+    signTransactionUrl: "https://phantom.app/ul/v1/signTransaction",
+    signAllTransactionsUrl: "https://phantom.app/ul/v1/signAllTransactions"
+  },
+  {
+    id: "solflare",
+    name: "Solflare",
+    icon: "https://solflare.com/favicon.ico",
+    appUrl: "https://solflare.com",
+    installUrl: "https://solflare.com/download",
+    encryptionPublicKeyParam: "solflare_encryption_public_key",
+    connectUrl: "https://solflare.com/ul/v1/connect",
+    signTransactionUrl: "https://solflare.com/ul/v1/signTransaction",
+    signAllTransactionsUrl: "https://solflare.com/ul/v1/signAllTransactions",
+    signAndSendTransactionUrl: "https://solflare.com/ul/v1/signAndSendTransaction"
+  },
+  {
+    id: "backpack",
+    name: "Backpack",
+    icon: "https://backpack.app/favicon.ico",
+    appUrl: "https://backpack.app",
+    installUrl: "https://backpack.app/download",
+    encryptionPublicKeyParam: "wallet_encryption_public_key",
+    connectUrl: "https://backpack.app/ul/v1/connect",
+    signTransactionUrl: "https://backpack.app/ul/v1/signTransaction",
+    signAllTransactionsUrl: "https://backpack.app/ul/v1/signAllTransactions",
+    signAndSendTransactionUrl: "https://backpack.app/ul/v1/signAndSendTransaction"
+  }
+];
+function getSolanaIosWallets(options = {}) {
+  if (!isSolanaIosBrowserWalletSupported()) {
+    return [];
+  }
+  const chains = options.chains?.length ? options.chains : DEFAULT_IOS_WALLET_CHAINS;
+  const callbackUrl = options.redirectUrl ?? getDefaultIosWalletRedirectUrl();
+  return IOS_WALLETS.map((wallet) => ({
+    name: wallet.name,
+    icon: wallet.icon,
+    chains,
+    platform: "mobile",
+    source: "deep-link",
+    appUrl: wallet.appUrl,
+    installUrl: wallet.installUrl,
+    callbackUrl,
+    capabilities: {
+      connect: true,
+      signTransaction: Boolean(wallet.signTransactionUrl),
+      signAllTransactions: Boolean(wallet.signAllTransactionsUrl),
+      signAndSendTransaction: Boolean(wallet.signAndSendTransactionUrl)
+    },
+    accounts: getStoredIosWalletAccount(wallet.id, chains),
+    wallet
+  }));
+}
+function adaptSolanaIosWallet(walletInfo, options = {}) {
+  const definition = getIosWalletDefinition(walletInfo);
+  let connecting = false;
+  let disconnecting = false;
+  let session = getStoredSession(definition.id);
+  function refreshSession() {
+    session = getStoredSession(definition.id);
+    options.onChange?.();
+  }
+  return {
+    get publicKey() {
+      return session?.publicKey ? new PublicKey(session.publicKey) : null;
+    },
+    get connected() {
+      return Boolean(session?.publicKey && session.session);
+    },
+    get connecting() {
+      return connecting;
+    },
+    get disconnecting() {
+      return disconnecting;
+    },
+    async connect() {
+      const callback = handleSolanaIosWalletCallback({ clearUrl: true });
+      if (callback?.walletId === definition.id) {
+        refreshSession();
+        return;
+      }
+      connecting = true;
+      options.onChange?.();
+      try {
+        launchConnect(definition, options);
+        await waitForRedirect();
+      } finally {
+        connecting = false;
+        options.onChange?.();
+      }
+    },
+    async disconnect() {
+      disconnecting = true;
+      options.onChange?.();
+      try {
+        removeStoredSession(definition.id);
+        refreshSession();
+      } finally {
+        disconnecting = false;
+        options.onChange?.();
+      }
+    },
+    signTransaction: definition.signTransactionUrl ? async (transaction) => {
+      const signedTransaction = await launchSignTransaction(definition, transaction, options);
+      return deserializeTransaction(transaction, signedTransaction);
+    } : void 0,
+    signAllTransactions: definition.signAllTransactionsUrl ? async (transactions) => {
+      const signedTransactions = await launchSignAllTransactions(
+        definition,
+        transactions,
+        options
+      );
+      return signedTransactions.map(
+        (transaction, index) => deserializeTransaction(transactions[index], transaction)
+      );
+    } : void 0,
+    signAndSendTransaction: definition.signAndSendTransactionUrl ? async (transaction, sendOptions) => launchSignAndSendTransaction(definition, transaction, sendOptions, options) : void 0
+  };
+}
+function handleSolanaIosWalletCallback(options = {}) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const url = new URL(window.location.href);
+  if (!hasIosWalletCallbackParams(url)) {
+    return null;
+  }
+  const errorCode = url.searchParams.get("errorCode");
+  const errorMessage = url.searchParams.get("errorMessage");
+  if (errorCode || errorMessage) {
+    clearPendingRequest();
+    cleanCallbackUrl(url, options.clearUrl);
+    throw new Error(errorMessage || `iOS wallet request failed: ${errorCode}`);
+  }
+  const pending = getPendingRequest();
+  if (!pending) {
+    cleanCallbackUrl(url, options.clearUrl);
+    throw new Error("Received an iOS wallet callback without a pending request");
+  }
+  const definition = getIosWalletDefinitionById(pending.walletId);
+  const walletEncryptionPublicKey = url.searchParams.get(definition.encryptionPublicKeyParam);
+  const nonce = url.searchParams.get("nonce");
+  const data = url.searchParams.get("data");
+  if (!nonce || !data) {
+    throw new Error("Received an incomplete iOS wallet callback");
+  }
+  const sharedSecret = getSharedSecret(
+    walletEncryptionPublicKey ?? getStoredSession(pending.walletId)?.walletEncryptionPublicKey,
+    pending.dappEncryptionSecretKey
+  );
+  const payload = decryptPayload(data, nonce, sharedSecret);
+  const result = createCallbackResult(pending, payload);
+  if (pending.method === "connect") {
+    if (!walletEncryptionPublicKey) {
+      throw new Error("iOS wallet connect callback did not include an encryption public key");
+    }
+    storeSession({
+      walletId: pending.walletId,
+      publicKey: getStringField(payload, "public_key"),
+      session: getStringField(payload, "session"),
+      dappEncryptionPublicKey: pending.dappEncryptionPublicKey,
+      dappEncryptionSecretKey: pending.dappEncryptionSecretKey,
+      walletEncryptionPublicKey,
+      sharedSecret: bs58.encode(sharedSecret)
+    });
+  }
+  clearPendingRequest();
+  cleanCallbackUrl(url, options.clearUrl);
+  return result;
+}
+function isSolanaIosWalletInfo(walletInfo) {
+  return walletInfo.source === "deep-link" && isIosWalletDefinition(walletInfo.wallet);
+}
+function isSolanaIosBrowserWalletSupported() {
+  return isIosBrowser();
+}
+function isIosBrowser() {
+  if (typeof window === "undefined" || typeof navigator === "undefined") {
+    return false;
+  }
+  const userAgent = navigator.userAgent;
+  const platform = navigator.platform;
+  const maxTouchPoints = navigator.maxTouchPoints ?? 0;
+  return /iPad|iPhone|iPod/i.test(userAgent) || platform === "MacIntel" && maxTouchPoints > 1;
+}
+function getDefaultIosWalletAppIdentity() {
+  if (typeof window === "undefined") {
+    return {
+      name: "Vue Solana App",
+      uri: "https://localhost"
+    };
+  }
+  return {
+    name: document.title || "Vue Solana App",
+    uri: window.location.origin,
+    icon: getDocumentIconUrl()
+  };
+}
+function getDefaultIosWalletRedirectUrl() {
+  if (typeof window === "undefined") {
+    return "https://localhost";
+  }
+  const url = new URL(window.location.href);
+  for (const param of CALLBACK_PARAMS) {
+    url.searchParams.delete(param);
+  }
+  return url.toString();
+}
+function launchConnect(definition, options) {
+  const keyPair = nacl.box.keyPair();
+  const pending = createPendingRequest(definition.id, "connect", keyPair, options.redirectUrl);
+  const appIdentity = options.appIdentity ?? getDefaultIosWalletAppIdentity();
+  const url = new URL(definition.connectUrl);
+  url.searchParams.set("app_url", appIdentity.uri);
+  url.searchParams.set("dapp_encryption_public_key", pending.dappEncryptionPublicKey);
+  url.searchParams.set("redirect_link", pending.redirectUrl);
+  if (options.cluster && options.cluster !== "localnet") {
+    url.searchParams.set("cluster", options.cluster);
+  }
+  storePendingRequest(pending);
+  openIosWalletUrl(url.toString());
+}
+async function launchSignTransaction(definition, transaction, options) {
+  const response = await launchEncryptedWalletRequest(definition, "signTransaction", options, {
+    transaction: bs58.encode(serializeTransaction(transaction))
+  });
+  if (!response.transaction) {
+    throw new Error("iOS wallet did not return a signed transaction");
+  }
+  return response.transaction;
+}
+async function launchSignAllTransactions(definition, transactions, options) {
+  const response = await launchEncryptedWalletRequest(definition, "signAllTransactions", options, {
+    transactions: transactions.map((transaction) => bs58.encode(serializeTransaction(transaction)))
+  });
+  if (!response.transactions) {
+    throw new Error("iOS wallet did not return signed transactions");
+  }
+  return response.transactions;
+}
+async function launchSignAndSendTransaction(definition, transaction, sendOptions, options) {
+  const response = await launchEncryptedWalletRequest(
+    definition,
+    "signAndSendTransaction",
+    options,
+    {
+      transaction: bs58.encode(serializeTransaction(transaction)),
+      sendOptions
+    }
+  );
+  if (!response.signature) {
+    throw new Error("iOS wallet did not return a transaction signature");
+  }
+  return { signature: response.signature };
+}
+async function launchEncryptedWalletRequest(definition, method, options, payload) {
+  const session = getStoredSession(definition.id);
+  if (!session) {
+    throw new Error("Connect the iOS wallet before signing");
+  }
+  const methodUrl = getIosWalletMethodUrl(definition, method);
+  const pending = createPendingRequest(
+    definition.id,
+    method,
+    {
+      publicKey: bs58.decode(session.dappEncryptionPublicKey),
+      secretKey: bs58.decode(session.dappEncryptionSecretKey)
+    },
+    options.redirectUrl
+  );
+  const nonce = nacl.randomBytes(nacl.box.nonceLength);
+  const encryptedPayload = encryptPayload(
+    { ...payload, session: session.session },
+    nonce,
+    bs58.decode(session.sharedSecret)
+  );
+  const url = new URL(methodUrl);
+  url.searchParams.set("dapp_encryption_public_key", session.dappEncryptionPublicKey);
+  url.searchParams.set("nonce", bs58.encode(nonce));
+  url.searchParams.set("redirect_link", pending.redirectUrl);
+  url.searchParams.set("payload", encryptedPayload);
+  storePendingRequest(pending);
+  openIosWalletUrl(url.toString());
+  return waitForRedirect();
+}
+function createPendingRequest(walletId, method, keyPair, redirectUrl) {
+  return {
+    id: createRequestId(),
+    walletId,
+    method,
+    dappEncryptionPublicKey: bs58.encode(keyPair.publicKey),
+    dappEncryptionSecretKey: bs58.encode(keyPair.secretKey),
+    redirectUrl: redirectUrl ?? getDefaultIosWalletRedirectUrl(),
+    createdAt: Date.now()
+  };
+}
+function createCallbackResult(pending, payload) {
+  if (pending.method === "connect") {
+    return {
+      walletId: pending.walletId,
+      method: pending.method,
+      publicKey: getStringField(payload, "public_key")
+    };
+  }
+  if (pending.method === "signTransaction") {
+    return {
+      walletId: pending.walletId,
+      method: pending.method,
+      transaction: bs58.decode(getStringField(payload, "transaction"))
+    };
+  }
+  if (pending.method === "signAllTransactions") {
+    const transactions = payload.transactions;
+    if (!Array.isArray(transactions) || transactions.some((transaction) => typeof transaction !== "string")) {
+      throw new Error("iOS wallet returned invalid signed transactions");
+    }
+    return {
+      walletId: pending.walletId,
+      method: pending.method,
+      transactions: transactions.map((transaction) => bs58.decode(transaction))
+    };
+  }
+  return {
+    walletId: pending.walletId,
+    method: pending.method,
+    signature: getStringField(payload, "signature")
+  };
+}
+function getIosWalletMethodUrl(definition, method) {
+  const url = definition[`${method}Url`];
+  if (!url) {
+    throw new Error(`${definition.name} does not support ${method} through iOS deeplinks`);
+  }
+  return url;
+}
+function getSharedSecret(walletEncryptionPublicKey, dappSecretKey) {
+  if (!walletEncryptionPublicKey) {
+    throw new Error("Missing iOS wallet encryption public key");
+  }
+  return nacl.box.before(bs58.decode(walletEncryptionPublicKey), bs58.decode(dappSecretKey));
+}
+function encryptPayload(payload, nonce, sharedSecret) {
+  return bs58.encode(nacl.box.after(encodeJson(payload), nonce, sharedSecret));
+}
+function decryptPayload(data, nonce, sharedSecret) {
+  const decrypted = nacl.box.open.after(bs58.decode(data), bs58.decode(nonce), sharedSecret);
+  if (!decrypted) {
+    throw new Error("Unable to decrypt iOS wallet callback");
+  }
+  return JSON.parse(new TextDecoder().decode(decrypted));
+}
+function encodeJson(value) {
+  return new TextEncoder().encode(JSON.stringify(value));
+}
+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 getStoredIosWalletAccount(walletId, chains) {
+  const session = getStoredSession(walletId);
+  if (!session) {
+    return [];
+  }
+  return [
+    {
+      address: session.publicKey,
+      publicKey: new PublicKey(session.publicKey).toBytes(),
+      chains
+    }
+  ];
+}
+function getStoredSession(walletId) {
+  const value = getStorage()?.getItem(`${SESSION_PREFIX}${walletId}`);
+  if (!value) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    removeStoredSession(walletId);
+    return null;
+  }
+}
+function storeSession(session) {
+  getStorage()?.setItem(`${SESSION_PREFIX}${session.walletId}`, JSON.stringify(session));
+}
+function removeStoredSession(walletId) {
+  getStorage()?.removeItem(`${SESSION_PREFIX}${walletId}`);
+}
+function getPendingRequest() {
+  const value = getStorage()?.getItem(PENDING_REQUEST_KEY);
+  if (!value) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    clearPendingRequest();
+    return null;
+  }
+}
+function storePendingRequest(request) {
+  getStorage()?.setItem(PENDING_REQUEST_KEY, JSON.stringify(request));
+}
+function clearPendingRequest() {
+  getStorage()?.removeItem(PENDING_REQUEST_KEY);
+}
+function getStorage() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function openIosWalletUrl(url) {
+  if (typeof window === "undefined") {
+    throw new Error("iOS wallet links are only available in browser runtimes");
+  }
+  window.location.assign(url);
+}
+function waitForRedirect() {
+  return new Promise(() => {
+  });
+}
+function hasIosWalletCallbackParams(url) {
+  for (const param of CALLBACK_PARAMS) {
+    if (url.searchParams.has(param)) {
+      return true;
+    }
+  }
+  return false;
+}
+function cleanCallbackUrl(url, clearUrl) {
+  if (!clearUrl || typeof window === "undefined") {
+    return;
+  }
+  for (const param of CALLBACK_PARAMS) {
+    url.searchParams.delete(param);
+  }
+  window.history.replaceState(window.history.state, document.title, url.toString());
+}
+function createRequestId() {
+  return bs58.encode(nacl.randomBytes(16));
+}
+function getStringField(payload, field) {
+  const value = payload[field];
+  if (typeof value !== "string" || !value) {
+    throw new Error(`iOS wallet callback is missing ${field}`);
+  }
+  return value;
+}
+function getIosWalletDefinition(walletInfo) {
+  if (!isIosWalletDefinition(walletInfo.wallet)) {
+    throw new Error("Solana wallet info is not an iOS wallet");
+  }
+  return walletInfo.wallet;
+}
+function getIosWalletDefinitionById(walletId) {
+  const definition = IOS_WALLETS.find((wallet) => wallet.id === walletId);
+  if (!definition) {
+    throw new Error(`Unknown iOS wallet: ${walletId}`);
+  }
+  return definition;
+}
+function isIosWalletDefinition(value) {
+  return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && IOS_WALLETS.some((wallet) => wallet.id === value.id);
+}
+function getDocumentIconUrl() {
+  const icon = document.querySelector(
+    'link[rel="icon"], link[rel="shortcut icon"], link[rel="apple-touch-icon"]'
+  );
+  return icon?.href;
+}
+
+export { adaptSolanaIosWallet, getDefaultIosWalletAppIdentity, getDefaultIosWalletRedirectUrl, getSolanaIosWallets, handleSolanaIosWalletCallback, isIosBrowser, isSolanaIosBrowserWalletSupported, isSolanaIosWalletInfo };

package/dist/types.d.cts

@@ -39,6 +39,13 @@ interface SolanaWalletInfo {
     source?: "wallet-standard" | "mobile-wallet-adapter" | "deep-link" | "protocol-link";
     appUrl?: string;
     installUrl?: string;
+    callbackUrl?: string;
+    capabilities?: {
+        connect?: boolean;
+        signTransaction?: boolean;
+        signAllTransactions?: boolean;
+        signAndSendTransaction?: boolean;
+    };
     accounts: readonly {
         address: string;
         publicKey: Uint8Array;

package/dist/types.d.mts

@@ -39,6 +39,13 @@ interface SolanaWalletInfo {
     source?: "wallet-standard" | "mobile-wallet-adapter" | "deep-link" | "protocol-link";
     appUrl?: string;
     installUrl?: string;
+    callbackUrl?: string;
+    capabilities?: {
+        connect?: boolean;
+        signTransaction?: boolean;
+        signAllTransactions?: boolean;
+        signAndSendTransaction?: boolean;
+    };
     accounts: readonly {
         address: string;
         publicKey: Uint8Array;

package/dist/types.d.ts

@@ -39,6 +39,13 @@ interface SolanaWalletInfo {
     source?: "wallet-standard" | "mobile-wallet-adapter" | "deep-link" | "protocol-link";
     appUrl?: string;
     installUrl?: string;
+    callbackUrl?: string;
+    capabilities?: {
+        connect?: boolean;
+        signTransaction?: boolean;
+        signAllTransactions?: boolean;
+        signAndSendTransaction?: boolean;
+    };
     accounts: readonly {
         address: string;
         publicKey: Uint8Array;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue-solana/core",
-  "version": "0.3.3",
+  "version": "0.4.1",
   "description": "Framework-agnostic primitives for Vue Solana libraries.",
   "license": "MIT",
   "keywords": [
@@ -40,6 +40,11 @@
       "import": "./dist/clusters.mjs",
       "require": "./dist/clusters.cjs"
     },
+    "./ios-wallet": {
+      "types": "./dist/ios-wallet.d.ts",
+      "import": "./dist/ios-wallet.mjs",
+      "require": "./dist/ios-wallet.cjs"
+    },
     "./mobile-wallet": {
       "types": "./dist/mobile-wallet.d.ts",
       "import": "./dist/mobile-wallet.mjs",
@@ -79,7 +84,8 @@
     "@wallet-standard/app": "^1.1.1",
     "@wallet-standard/base": "^1.1.1",
     "@wallet-standard/features": "^1.1.1",
-    "bs58": "^6.0.0"
+    "bs58": "^6.0.0",
+    "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
     "typescript": "^5.8.3",