@vue-solana/core 2.6.1 → 3.0.0

package/dist/shared/core.eIBHqmLq.cjs

@@ -1,598 +0,0 @@
-'use strict';
-
-const kit = require('@solana/kit');
-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 DEFAULT_IOS_WALLET_CHAINS = [
-  "solana:mainnet",
-  "solana:devnet"
-];
-const CALLBACK_PARAMS = /* @__PURE__ */ new Set([
-  "data",
-  "nonce",
-  "errorCode",
-  "errorMessage",
-  "phantom_encryption_public_key",
-  "solflare_encryption_public_key",
-  "wallet_encryption_public_key"
-]);
-function isSolanaIosBrowserWalletSupported() {
-  return isIosBrowser();
-}
-function isIosBrowser() {
-  if (typeof window === "undefined" || typeof navigator === "undefined") {
-    return false;
-  }
-  const userAgentDataPlatform = getNavigatorUserAgentDataPlatform();
-  if (isIosPlatform(userAgentDataPlatform)) {
-    return true;
-  }
-  const userAgent = navigator.userAgent;
-  const platform = getNavigatorPlatform();
-  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 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 getDocumentIconUrl() {
-  const icon = document.querySelector(
-    'link[rel="icon"], link[rel="shortcut icon"], link[rel="apple-touch-icon"]'
-  );
-  return icon?.href;
-}
-function getNavigatorUserAgentDataPlatform() {
-  const userAgentData = Reflect.get(navigator, "userAgentData");
-  if (!isObjectRecord(userAgentData)) {
-    return void 0;
-  }
-  const platform = Reflect.get(userAgentData, "platform");
-  return typeof platform === "string" ? platform : void 0;
-}
-function getNavigatorPlatform() {
-  const platform = Reflect.get(navigator, "platform");
-  return typeof platform === "string" ? platform : "";
-}
-function isIosPlatform(platform) {
-  return platform?.toLowerCase() === "ios";
-}
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-
-const nacl = resolveTweetNaCl();
-function createRequestId() {
-  return bs58__default.encode(nacl.randomBytes(16));
-}
-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 resolveTweetNaCl() {
-  const moduleDefault = naclModule__namespace.default;
-  const globalNacl = globalThis.nacl;
-  return "box" in naclModule__namespace ? naclModule__namespace : moduleDefault ?? globalNacl;
-}
-function encodeJson(value) {
-  return new TextEncoder().encode(JSON.stringify(value));
-}
-
-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 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);
-}
-
-const PENDING_REQUEST_KEY = "vue-solana:ios-wallet:pending";
-const PENDING_REQUEST_TTL_MS = 10 * 60 * 1e3;
-const SESSION_PREFIX = "vue-solana:ios-wallet:session:";
-function createPendingRequest(walletId, method, keyPair, redirectUrl, requestedTransactionCount) {
-  return {
-    id: createRequestId(),
-    walletId,
-    method,
-    dappEncryptionPublicKey: bs58__default.encode(keyPair.publicKey),
-    dappEncryptionSecretKey: bs58__default.encode(keyPair.secretKey),
-    redirectUrl: redirectUrl ?? getDefaultIosWalletRedirectUrl(),
-    createdAt: Date.now(),
-    requestedTransactionCount
-  };
-}
-function getStoredIosWalletAccount(walletId, chains) {
-  const session = getStoredSession(walletId);
-  if (!session) {
-    return [];
-  }
-  return [
-    {
-      address: session.publicKey,
-      publicKey: bs58__default.decode(session.publicKey),
-      chains
-    }
-  ];
-}
-function getStoredSession(walletId) {
-  const value = getStorage()?.getItem(`${SESSION_PREFIX}${walletId}`);
-  if (!value) {
-    return null;
-  }
-  try {
-    const session = JSON.parse(value);
-    if (!kit.isAddress(session.publicKey)) {
-      throw new Error("Invalid stored public key");
-    }
-    return session;
-  } 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 isPendingRequestExpired(request) {
-  return Date.now() - request.createdAt > PENDING_REQUEST_TTL_MS;
-}
-function getStorage() {
-  if (typeof window === "undefined") {
-    return null;
-  }
-  try {
-    return window.sessionStorage;
-  } catch {
-    return null;
-  }
-}
-
-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");
-  }
-  if (isPendingRequestExpired(pending)) {
-    clearPendingRequest();
-    cleanCallbackUrl(url, options.clearUrl);
-    throw new Error("Received an expired iOS wallet callback");
-  }
-  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) {
-    clearPendingRequest();
-    cleanCallbackUrl(url, options.clearUrl);
-    throw new Error("Received an incomplete iOS wallet callback");
-  }
-  try {
-    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");
-      }
-      const publicKey = getPublicKeyField(payload, "public_key");
-      storeSession({
-        walletId: pending.walletId,
-        publicKey,
-        session: getStringField(payload, "session"),
-        dappEncryptionPublicKey: pending.dappEncryptionPublicKey,
-        dappEncryptionSecretKey: pending.dappEncryptionSecretKey,
-        walletEncryptionPublicKey,
-        sharedSecret: bs58__default.encode(sharedSecret)
-      });
-    }
-    return result;
-  } finally {
-    clearPendingRequest();
-    cleanCallbackUrl(url, options.clearUrl);
-  }
-}
-function createCallbackResult(pending, payload) {
-  if (pending.method === "connect") {
-    return {
-      walletId: pending.walletId,
-      method: pending.method,
-      publicKey: getPublicKeyField(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");
-    }
-    if (typeof pending.requestedTransactionCount === "number" && transactions.length !== pending.requestedTransactionCount) {
-      throw new Error(
-        `iOS wallet returned ${transactions.length} signed transactions for ${pending.requestedTransactionCount} requested 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 getStringField(payload, field) {
-  const value = payload[field];
-  if (typeof value !== "string" || !value) {
-    throw new Error(`iOS wallet callback is missing ${field}`);
-  }
-  return value;
-}
-function getPublicKeyField(payload, field) {
-  const value = getStringField(payload, field);
-  if (!kit.isAddress(value)) {
-    throw new Error(`iOS wallet callback returned an invalid ${field}`);
-  }
-  return value;
-}
-
-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(new Uint8Array(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(new Uint8Array(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(new Uint8Array(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,
-    method === "signAllTransactions" && Array.isArray(payload.transactions) ? payload.transactions.length : void 0
-  );
-  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 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 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,
-      disconnect: 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 ? 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) => {
-      return launchSignTransaction(definition, transaction, options);
-    } : void 0,
-    signAllTransactions: definition.signAllTransactionsUrl ? async (transactions) => {
-      const signedTransactions = await launchSignAllTransactions(
-        definition,
-        transactions,
-        options
-      );
-      if (signedTransactions.length !== transactions.length) {
-        throw new Error(
-          `iOS wallet returned ${signedTransactions.length} signed transactions for ${transactions.length} requested transactions`
-        );
-      }
-      return signedTransactions;
-    } : void 0,
-    signAndSendTransaction: definition.signAndSendTransactionUrl ? async (transaction, sendOptions) => launchSignAndSendTransaction(definition, transaction, sendOptions, options) : void 0
-  };
-}
-function isSolanaIosWalletInfo(walletInfo) {
-  return walletInfo.source === "deep-link" && isIosWalletDefinition(walletInfo.wallet);
-}
-function getIosWalletDefinition(walletInfo) {
-  if (!isIosWalletDefinition(walletInfo.wallet)) {
-    throw new Error("Solana wallet info is not an iOS wallet");
-  }
-  return walletInfo.wallet;
-}
-
-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/timeout.cjs

@@ -1,32 +0,0 @@
-'use strict';
-
-const errors = require('./errors.cjs');
-
-function withTimeout(promise, timeoutMs, createError) {
-  if (timeoutMs === void 0) {
-    return promise;
-  }
-  let timeoutId;
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => {
-      timeoutId = setTimeout(() => {
-        try {
-          reject(createError());
-        } catch (error) {
-          reject(error);
-        }
-      }, timeoutMs);
-    })
-  ]).finally(() => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-  });
-}
-function withSolanaTimeout(promise, timeoutMs, message) {
-  return withTimeout(promise, timeoutMs, () => errors.createSolanaError("TRANSACTION_TIMEOUT", message));
-}
-
-exports.withSolanaTimeout = withSolanaTimeout;
-exports.withTimeout = withTimeout;

package/dist/timeout.d.cts

@@ -1,4 +0,0 @@
-declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number | undefined, createError: () => unknown): Promise<T>;
-declare function withSolanaTimeout<T>(promise: Promise<T>, timeoutMs: number | undefined, message: string): Promise<T>;
-
-export { withSolanaTimeout, withTimeout };

package/dist/token-accounts.cjs

@@ -1,72 +0,0 @@
-'use strict';
-
-const kit = require('@solana/kit');
-const errors = require('./errors.cjs');
-
-const TOKEN_PROGRAM_ADDRESS = kit.address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
-const TOKEN_2022_PROGRAM_ADDRESS = kit.address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
-async function getTokenAccountsByOwner(client, owner, options = {}) {
-  const programIds = options.programId ? [options.programId] : [TOKEN_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS];
-  try {
-    const results = await Promise.all(
-      programIds.map(
-        (programId) => fetchParsedTokenAccounts(client, owner, { programId }, options.commitment)
-      )
-    );
-    return results.flat();
-  } catch (cause) {
-    throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
-  }
-}
-async function getTokenAccount(client, address2, commitment) {
-  try {
-    const response = await client.rpc.getAccountInfo(address2, { encoding: "jsonParsed", commitment }).send();
-    const accountInfo = response.value;
-    if (!accountInfo || !isParsedTokenAccount(accountInfo.data) || accountInfo.data.parsed.type !== "account") {
-      return null;
-    }
-    return tokenAccountInfoFromParsed(address2, accountInfo.data);
-  } catch (cause) {
-    throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
-  }
-}
-async function getTokenBalance(client, mint, owner, commitment) {
-  try {
-    const [account] = await fetchParsedTokenAccounts(client, owner, { mint }, commitment);
-    if (!account) {
-      return null;
-    }
-    return { amount: account.amount, decimals: account.decimals };
-  } catch (cause) {
-    throw errors.normalizeSolanaError(cause, "RPC_FAILURE");
-  }
-}
-async function fetchParsedTokenAccounts(client, owner, filter, commitment) {
-  const response = await client.rpc.getTokenAccountsByOwner(owner, filter, { encoding: "jsonParsed", commitment }).send();
-  return response.value.filter(({ account }) => isParsedTokenAccount(account.data)).map(({ pubkey, account }) => tokenAccountInfoFromParsed(pubkey, account.data));
-}
-function isParsedTokenAccount(data) {
-  return typeof data === "object" && data !== null && "parsed" in data;
-}
-function tokenAccountInfoFromParsed(address2, data) {
-  if (data.parsed.type !== "account") {
-    throw new Error(`Token account ${address2} is not a parsed token account`);
-  }
-  const parsed = data.parsed.info;
-  if (!parsed) {
-    throw new Error(`Token account ${address2} has no parsed data`);
-  }
-  return {
-    address: address2,
-    mint: parsed.mint,
-    owner: parsed.owner,
-    amount: BigInt(parsed.tokenAmount.amount),
-    decimals: parsed.tokenAmount.decimals,
-    state: parsed.state,
-    isNative: parsed.isNative
-  };
-}
-
-exports.getTokenAccount = getTokenAccount;
-exports.getTokenAccountsByOwner = getTokenAccountsByOwner;
-exports.getTokenBalance = getTokenBalance;