@phantom/browser-injected-sdk 0.0.9

package/dist/chunk-QNVIOBKG.mjs

@@ -0,0 +1,382 @@
+import {
+  __privateAdd,
+  __privateMethod
+} from "./chunk-GV6AIHPN.mjs";
+
+// src/ethereum/strategies/injected.ts
+var MAX_RETRIES = 4;
+var BASE_DELAY = 100;
+var _getProvider, getProvider_fn;
+var InjectedEthereumStrategy = class {
+  constructor() {
+    __privateAdd(this, _getProvider);
+    this.type = "injected" /* INJECTED */;
+  }
+  load() {
+    let retryCount = 0;
+    const scheduleRetry = (resolve, reject) => {
+      const delay = BASE_DELAY * Math.pow(2, Math.min(retryCount, 5));
+      setTimeout(() => {
+        if (__privateMethod(this, _getProvider, getProvider_fn).call(this)) {
+          resolve();
+          return;
+        }
+        retryCount++;
+        if (retryCount >= MAX_RETRIES) {
+          reject();
+        } else {
+          scheduleRetry(resolve, reject);
+        }
+      }, delay);
+    };
+    return new Promise((resolve, reject) => {
+      scheduleRetry(() => resolve(this), reject);
+    });
+  }
+  get isConnected() {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    return provider?.isConnected && provider.selectedAddress ? true : false;
+  }
+  async connect({ onlyIfTrusted }) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    if (provider.isConnected && provider.selectedAddress) {
+      return this.getAccounts();
+    }
+    try {
+      const accounts = await provider.request({
+        method: onlyIfTrusted ? "eth_accounts" : "eth_requestAccounts"
+      });
+      return accounts;
+    } catch (_) {
+      return void 0;
+    }
+  }
+  async disconnect() {
+    return Promise.resolve();
+  }
+  async getAccounts() {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      return [];
+    }
+    try {
+      const accounts = await provider.request({ method: "eth_accounts" });
+      return accounts || [];
+    } catch (_) {
+      return [];
+    }
+  }
+  async signMessage(message, address) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    if (!provider.isConnected) {
+      throw new Error("Provider is not connected.");
+    }
+    const signature = await provider.request({
+      method: "eth_sign",
+      params: [address, message]
+    });
+    return signature;
+  }
+  async signPersonalMessage(message, address) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    if (!provider.isConnected) {
+      throw new Error("Provider is not connected.");
+    }
+    const signature = await provider.request({
+      method: "personal_sign",
+      params: [message, address]
+    });
+    return signature;
+  }
+  async signTypedData(typedData, address) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    if (!provider.isConnected) {
+      throw new Error("Provider is not connected.");
+    }
+    const signature = await provider.request({
+      method: "eth_signTypedData_v4",
+      params: [address, JSON.stringify(typedData)]
+    });
+    return signature;
+  }
+  async signIn(signInData) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    const message = `Sign in to ${signInData.domain || "this application"}`;
+    const address = provider.selectedAddress;
+    if (!address) {
+      throw new Error("No address available.");
+    }
+    const signature = await this.signPersonalMessage(message, address);
+    return {
+      address,
+      signature,
+      signedMessage: message
+    };
+  }
+  async sendTransaction(transaction) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    if (!provider.isConnected) {
+      throw new Error("Provider is not connected.");
+    }
+    const txHash = await provider.request({
+      method: "eth_sendTransaction",
+      params: [transaction]
+    });
+    return txHash;
+  }
+  async signTransaction(transaction) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    if (!provider.isConnected) {
+      throw new Error("Provider is not connected.");
+    }
+    const signedTx = await provider.request({
+      method: "eth_signTransaction",
+      params: [transaction]
+    });
+    return signedTx;
+  }
+  async getChainId() {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    const chainId = await provider.request({ method: "eth_chainId" });
+    return chainId;
+  }
+  async switchChain(chainId) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    await provider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId }]
+    });
+  }
+};
+_getProvider = new WeakSet();
+getProvider_fn = function() {
+  return window?.phantom?.ethereum;
+};
+
+// src/ethereum/getProvider.ts
+async function getProvider(strategy = "injected" /* INJECTED */) {
+  if (strategy === "injected") {
+    const provider = new InjectedEthereumStrategy();
+    try {
+      await provider.load();
+      return provider;
+    } catch (error) {
+      throw new Error("Provider not found.");
+    }
+  } else {
+    throw new Error("Invalid provider type.");
+  }
+}
+
+// src/ethereum/eventListeners.ts
+var eventListeners = /* @__PURE__ */ new Map();
+function addEventListener(event, callback) {
+  if (!eventListeners.has(event)) {
+    eventListeners.set(event, /* @__PURE__ */ new Set());
+  }
+  const listeners = eventListeners.get(event);
+  listeners.add(callback);
+  return () => removeEventListener(event, callback);
+}
+function removeEventListener(event, callback) {
+  const listeners = eventListeners.get(event);
+  if (listeners) {
+    listeners.delete(callback);
+  }
+}
+function triggerEvent(event, data) {
+  const listeners = eventListeners.get(event);
+  if (listeners) {
+    listeners.forEach((callback) => {
+      try {
+        callback(data);
+      } catch (error) {
+        console.error(`Error in ${event} event listener:`, error);
+      }
+    });
+  }
+}
+
+// src/ethereum/connect.ts
+async function connect() {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (provider.isConnected) {
+    const accounts = await provider.getAccounts();
+    return accounts;
+  }
+  try {
+    const accounts = await provider.connect({ onlyIfTrusted: true });
+    if (accounts && accounts.length > 0) {
+      triggerEvent("connect", accounts);
+      return accounts;
+    }
+  } catch (error) {
+  }
+  try {
+    const accounts = await provider.connect({ onlyIfTrusted: false });
+    if (accounts && accounts.length > 0) {
+      triggerEvent("connect", accounts);
+      return accounts;
+    }
+  } catch (error) {
+  }
+  throw new Error("Failed to connect to Phantom.");
+}
+
+// src/ethereum/disconnect.ts
+async function disconnect() {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  await provider.disconnect();
+  triggerEvent("disconnect", []);
+}
+
+// src/ethereum/getAccounts.ts
+async function getAccounts() {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  return provider.getAccounts();
+}
+
+// src/ethereum/signMessage.ts
+async function signMessage(message, address) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (!provider.isConnected) {
+    await provider.connect({ onlyIfTrusted: false });
+  }
+  return provider.signMessage(message, address);
+}
+async function signPersonalMessage(message, address) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (!provider.isConnected) {
+    await provider.connect({ onlyIfTrusted: false });
+  }
+  return provider.signPersonalMessage(message, address);
+}
+async function signTypedData(typedData, address) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (!provider.isConnected) {
+    await provider.connect({ onlyIfTrusted: false });
+  }
+  return provider.signTypedData(typedData, address);
+}
+
+// src/ethereum/signIn.ts
+async function signIn(signInData) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (!provider.isConnected) {
+    await provider.connect({ onlyIfTrusted: false });
+  }
+  return provider.signIn(signInData);
+}
+
+// src/ethereum/sendTransaction.ts
+async function sendTransaction(transaction) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (!provider.isConnected) {
+    await provider.connect({ onlyIfTrusted: false });
+  }
+  return provider.sendTransaction(transaction);
+}
+async function signTransaction(transaction) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (!provider.isConnected) {
+    await provider.connect({ onlyIfTrusted: false });
+  }
+  return provider.signTransaction(transaction);
+}
+
+// src/ethereum/chainUtils.ts
+async function getChainId() {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  return provider.getChainId();
+}
+async function switchChain(chainId) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  return provider.switchChain(chainId);
+}
+
+// src/ethereum/plugin.ts
+var ethereum = {
+  connect,
+  disconnect,
+  getAccounts,
+  signMessage,
+  signPersonalMessage,
+  signTypedData,
+  signIn,
+  sendTransaction,
+  signTransaction,
+  getChainId,
+  switchChain,
+  addEventListener,
+  removeEventListener
+};
+function createEthereumPlugin() {
+  return {
+    name: "ethereum",
+    create: () => ethereum
+  };
+}
+
+export {
+  createEthereumPlugin
+};

package/dist/ethereum/index.d.ts

@@ -0,0 +1 @@
+export { d as EthereumEventType, b as EthereumSignInData, E as EthereumTransaction, a as PhantomEthereumProvider, c as createEthereumPlugin } from '../index-2f448acb.js';