@phantom/browser-injected-sdk 0.0.9

package/dist/index.js

@@ -0,0 +1,452 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createEthereumPlugin: () => createEthereumPlugin,
+  createExtensionPlugin: () => createExtensionPlugin,
+  createPhantom: () => createPhantom,
+  isPhantomExtensionInstalled: () => isInstalled
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/extension/isInstalled.ts
+function isInstalled() {
+  try {
+    const phantom = window.phantom;
+    return !!phantom;
+  } catch (error) {
+    return false;
+  }
+}
+
+// src/extension/plugin.ts
+var extension = {
+  isInstalled
+};
+function createExtensionPlugin() {
+  return {
+    name: "extension",
+    create: () => extension
+  };
+}
+
+// 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
+  };
+}
+
+// src/index.ts
+function createPhantom({ plugins = [] }) {
+  const phantom = {};
+  for (const plugin of plugins) {
+    phantom[plugin.name] = plugin.create();
+  }
+  return phantom;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEthereumPlugin,
+  createExtensionPlugin,
+  createPhantom,
+  isPhantomExtensionInstalled
+});

package/dist/index.mjs

@@ -0,0 +1,41 @@
+import {
+  createEthereumPlugin
+} from "./chunk-QNVIOBKG.mjs";
+import "./chunk-WUKYLWAZ.mjs";
+import "./chunk-GV6AIHPN.mjs";
+
+// src/extension/isInstalled.ts
+function isInstalled() {
+  try {
+    const phantom = window.phantom;
+    return !!phantom;
+  } catch (error) {
+    return false;
+  }
+}
+
+// src/extension/plugin.ts
+var extension = {
+  isInstalled
+};
+function createExtensionPlugin() {
+  return {
+    name: "extension",
+    create: () => extension
+  };
+}
+
+// src/index.ts
+function createPhantom({ plugins = [] }) {
+  const phantom = {};
+  for (const plugin of plugins) {
+    phantom[plugin.name] = plugin.create();
+  }
+  return phantom;
+}
+export {
+  createEthereumPlugin,
+  createExtensionPlugin,
+  createPhantom,
+  isInstalled as isPhantomExtensionInstalled
+};

package/dist/solana/index.d.ts

@@ -0,0 +1,139 @@
+import { P as Plugin } from '../index-2f448acb.js';
+import { Transaction as Transaction$1 } from '@solana/kit';
+import { VersionedTransaction as VersionedTransaction$1 } from '@solana/web3.js';
+
+declare function connect(): Promise<string | undefined>;
+
+declare function disconnect(): Promise<void>;
+
+type Transaction = {
+    message: Uint8Array;
+    recentBlockhash: string;
+    feePayer: string;
+    instructions: any[];
+    signers: string[];
+    version: number;
+};
+type VersionedTransaction = {
+    signatures: Uint8Array[];
+    message: {
+        deserialize: (serializedTransaction: Uint8Array) => VersionedTransaction;
+        serialize: (transaction: VersionedTransaction) => Uint8Array;
+    };
+};
+type SendOptions = {
+    skipPreflight?: boolean;
+    preflightCommitment?: string;
+    maxRetries?: number;
+    minContextSlot?: number;
+};
+type PublicKey = {
+    toString: () => string;
+    toBase58: () => string;
+};
+type SolanaSignInData = {
+    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 DisplayEncoding = "utf8" | "hex";
+type PhantomEventType = "connect" | "disconnect" | "accountChanged";
+interface PhantomSolanaProvider {
+    isPhantom: boolean;
+    publicKey: PublicKey | null;
+    isConnected: boolean;
+    connect: (opts?: {
+        onlyIfTrusted?: boolean;
+    }) => Promise<{
+        publicKey: PublicKey;
+    }>;
+    disconnect: () => Promise<void>;
+    signMessage: (message: Uint8Array, display?: DisplayEncoding) => Promise<{
+        signature: Uint8Array;
+        publicKey: PublicKey;
+    }>;
+    signIn: (signInData: SolanaSignInData) => Promise<{
+        address: PublicKey;
+        signature: Uint8Array;
+        signedMessage: Uint8Array;
+    }>;
+    signAndSendTransaction: (transaction: Transaction | VersionedTransaction, options?: SendOptions) => Promise<{
+        signature: string;
+        publicKey?: string;
+    }>;
+    signAllTransactions: (transactions: (Transaction | VersionedTransaction)[]) => Promise<(Transaction | VersionedTransaction)[]>;
+    signTransaction: (transaction: Transaction | VersionedTransaction) => Promise<Transaction | VersionedTransaction>;
+    on: (event: "connect" | "disconnect" | "accountChanged", handler: (publicKey?: PublicKey) => void) => void;
+    off: (event: "connect" | "disconnect" | "accountChanged", handler: (publicKey?: PublicKey) => void) => void;
+}
+
+type ConnectCallback = (publicKey: string) => void;
+type DisconnectCallback = () => void;
+type AccountChangedCallback = (publicKey: string) => void;
+type PhantomEventCallback = ConnectCallback | DisconnectCallback | AccountChangedCallback;
+
+declare function getAccount(): Promise<string | undefined>;
+
+/**
+ * Signs and sends a transaction using the Phantom provider.
+ * @param transaction The transaction to sign and send.
+ * @returns A promise that resolves with the transaction signature and optionally the public key.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function signAndSendTransaction(transaction: Transaction$1 | VersionedTransaction$1): Promise<{
+    signature: string;
+    address?: string;
+}>;
+
+/**
+ * Signs in with Solana using the Phantom provider.
+ * @param signInData The sign-in data.
+ * @returns A promise that resolves with the address, signature, and signed message.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function signIn(signInData: SolanaSignInData): Promise<{
+    address: string;
+    signature: Uint8Array;
+    signedMessage: Uint8Array;
+}>;
+
+/**
+ * Signs a message using the Phantom provider.
+ * @param message The message to sign (as a Uint8Array).
+ * @param display The display encoding for the message (optional, defaults to utf8).
+ * @returns A promise that resolves with the signature and public key.
+ * @throws Error if Phantom provider is not found or if the operation fails.
+ */
+declare function signMessage(message: Uint8Array, display?: DisplayEncoding): Promise<{
+    signature: Uint8Array;
+    address: string;
+}>;
+
+type Solana = {
+    connect: typeof connect;
+    disconnect: typeof disconnect;
+    getAccount: typeof getAccount;
+    signMessage: typeof signMessage;
+    signIn: typeof signIn;
+    signAndSendTransaction: typeof signAndSendTransaction;
+    addEventListener: (event: PhantomEventType, callback: PhantomEventCallback) => () => void;
+    removeEventListener: (event: PhantomEventType, callback: PhantomEventCallback) => void;
+};
+declare function createSolanaPlugin(): Plugin<Solana>;
+
+declare module "../index" {
+    interface Phantom {
+        solana: Solana;
+    }
+}
+
+export { PhantomSolanaProvider, SolanaSignInData, createSolanaPlugin };