@phantom/browser-injected-sdk 0.0.9

package/dist/ethereum/index.js

@@ -0,0 +1,416 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/ethereum/index.ts
+var ethereum_exports = {};
+__export(ethereum_exports, {
+  createEthereumPlugin: () => createEthereumPlugin
+});
+module.exports = __toCommonJS(ethereum_exports);
+
+// 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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEthereumPlugin
+});

package/dist/ethereum/index.mjs

@@ -0,0 +1,8 @@
+import {
+  createEthereumPlugin
+} from "../chunk-QNVIOBKG.mjs";
+import "../chunk-WUKYLWAZ.mjs";
+import "../chunk-GV6AIHPN.mjs";
+export {
+  createEthereumPlugin
+};

package/dist/index-2f448acb.d.ts

@@ -0,0 +1,168 @@
+declare function isInstalled(): boolean;
+
+type Extension = {
+    isInstalled: typeof isInstalled;
+};
+declare function createExtensionPlugin(): Plugin<Extension>;
+
+declare module "../index" {
+    interface Phantom {
+        extension: Extension;
+    }
+}
+
+declare function connect(): Promise<string[]>;
+
+declare function disconnect(): Promise<void>;
+
+type EthereumTransaction = {
+    to?: string;
+    from?: string;
+    value?: string;
+    gas?: string;
+    gasPrice?: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+    data?: string;
+    nonce?: string;
+    type?: string;
+    chainId?: string;
+};
+type EthereumSignInData = {
+    domain?: string;
+    address?: string;
+    statement?: string;
+    uri?: string;
+    version?: string;
+    chainId?: string;
+    nonce?: string;
+    issuedAt?: string;
+    expirationTime?: string;
+    notBefore?: string;
+    requestId?: string;
+    resources?: string[];
+};
+type EthereumEventType = "connect" | "disconnect" | "accountsChanged" | "chainChanged";
+interface PhantomEthereumProvider {
+    isPhantom: boolean;
+    selectedAddress: string | null;
+    chainId: string;
+    isConnected: boolean;
+    request: (args: {
+        method: string;
+        params?: any[];
+    }) => Promise<any>;
+    on: (event: EthereumEventType, handler: (...args: any[]) => void) => void;
+    off: (event: EthereumEventType, handler: (...args: any[]) => void) => void;
+    removeAllListeners: (event?: EthereumEventType) => void;
+}
+
+type PhantomEthereumEventCallback = (data: any) => void;
+
+declare function getAccounts(): Promise<string[]>;
+
+/**
+ * Signs a message using the Phantom Ethereum provider.
+ * @param message The message to sign (as a string).
+ * @param address The address to sign with.
+ * @returns A promise that resolves with the signature.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function signMessage(message: string, address: string): Promise<string>;
+/**
+ * Signs a personal message using the Phantom Ethereum provider.
+ * @param message The message to sign (as a string).
+ * @param address The address to sign with.
+ * @returns A promise that resolves with the signature.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function signPersonalMessage(message: string, address: string): Promise<string>;
+/**
+ * Signs typed data using the Phantom Ethereum provider.
+ * @param typedData The typed data to sign.
+ * @param address The address to sign with.
+ * @returns A promise that resolves with the signature.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function signTypedData(typedData: any, address: string): Promise<string>;
+
+/**
+ * Signs in using the Phantom Ethereum provider.
+ * @param signInData The sign-in data.
+ * @returns A promise that resolves with the signature data.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function signIn(signInData: EthereumSignInData): Promise<{
+    address: string;
+    signature: string;
+    signedMessage: string;
+}>;
+
+/**
+ * Sends a transaction using the Phantom Ethereum provider.
+ * @param transaction The transaction to send.
+ * @returns A promise that resolves with the transaction hash.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function sendTransaction(transaction: EthereumTransaction): Promise<string>;
+/**
+ * Signs a transaction using the Phantom Ethereum provider.
+ * @param transaction The transaction to sign.
+ * @returns A promise that resolves with the signed transaction.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function signTransaction(transaction: EthereumTransaction): Promise<string>;
+
+/**
+ * Gets the current chain ID.
+ * @returns A promise that resolves with the chain ID.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function getChainId(): Promise<string>;
+/**
+ * Switches to a different chain.
+ * @param chainId The chain ID to switch to.
+ * @returns A promise that resolves when the switch is complete.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function switchChain(chainId: string): Promise<void>;
+
+type Ethereum = {
+    connect: typeof connect;
+    disconnect: typeof disconnect;
+    getAccounts: typeof getAccounts;
+    signMessage: typeof signMessage;
+    signPersonalMessage: typeof signPersonalMessage;
+    signTypedData: typeof signTypedData;
+    signIn: typeof signIn;
+    sendTransaction: typeof sendTransaction;
+    signTransaction: typeof signTransaction;
+    getChainId: typeof getChainId;
+    switchChain: typeof switchChain;
+    addEventListener: (event: EthereumEventType, callback: PhantomEthereumEventCallback) => () => void;
+    removeEventListener: (event: EthereumEventType, callback: PhantomEthereumEventCallback) => void;
+};
+declare function createEthereumPlugin(): Plugin<Ethereum>;
+
+declare module "../index" {
+    interface Phantom {
+        ethereum: Ethereum;
+    }
+}
+
+type Plugin<T> = {
+    name: string;
+    create: () => T;
+};
+type CreatePhantomConfig = {
+    plugins?: Plugin<unknown>[];
+};
+interface Phantom {
+}
+/**
+ * Creates a Phantom instance with the provided plugins.
+ * Each plugin extends the Phantom interface via declaration merging.
+ */
+declare function createPhantom({ plugins }: CreatePhantomConfig): Phantom;
+
+export { CreatePhantomConfig as C, EthereumTransaction as E, Plugin as P, PhantomEthereumProvider as a, EthereumSignInData as b, createEthereumPlugin as c, EthereumEventType as d, Phantom as e, createPhantom as f, createExtensionPlugin as g, isInstalled as i };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { C as CreatePhantomConfig, e as Phantom, P as Plugin, c as createEthereumPlugin, g as createExtensionPlugin, f as createPhantom, i as isPhantomExtensionInstalled } from './index-2f448acb.js';