@phantom/browser-injected-sdk 0.0.9

package/dist/solana/index.js

@@ -0,0 +1,413 @@
+"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/solana/index.ts
+var solana_exports = {};
+__export(solana_exports, {
+  createSolanaPlugin: () => createSolanaPlugin
+});
+module.exports = __toCommonJS(solana_exports);
+
+// src/solana/utils/transactionToVersionedTransaction.ts
+var import_transactions = require("@solana/transactions");
+function transactionToVersionedTransaction(transaction) {
+  const serialized = (0, import_transactions.getTransactionEncoder)().encode(transaction);
+  const fakeVersioned = {
+    serialize() {
+      return new Uint8Array(serialized);
+    }
+  };
+  return fakeVersioned;
+}
+
+// src/solana/strategies/injected.ts
+var import_compat = require("@solana/compat");
+var MAX_RETRIES = 4;
+var BASE_DELAY = 100;
+var _getProvider, getProvider_fn;
+var InjectedSolanaStrategy = 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.publicKey ? 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.publicKey) {
+      return this.getAccount() ?? void 0;
+    }
+    try {
+      const result = await provider.connect({ onlyIfTrusted });
+      return result.publicKey.toString();
+    } catch (_) {
+      return void 0;
+    }
+  }
+  async disconnect() {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    await provider.disconnect();
+  }
+  async getAccount() {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (provider && provider.isConnected && provider.publicKey) {
+      return Promise.resolve(provider.publicKey.toString());
+    }
+    return Promise.resolve(void 0);
+  }
+  async signMessage(message, display) {
+    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 result = await provider.signMessage(message, display);
+    return {
+      signature: result.signature,
+      address: result.publicKey.toString()
+    };
+  }
+  async signIn(signInData) {
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this);
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    const result = await provider.signIn(signInData);
+    return {
+      address: result.address.toString(),
+      signature: result.signature,
+      signedMessage: result.signedMessage
+    };
+  }
+  async signAndSendTransaction(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 versionedTransaction = transactionToVersionedTransaction(transaction);
+    const result = await provider.signAndSendTransaction(versionedTransaction);
+    return {
+      signature: result.signature,
+      address: result.publicKey
+    };
+  }
+  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 versionedTransaction = transactionToVersionedTransaction(transaction);
+    const result = await provider.signTransaction(versionedTransaction);
+    const responseTransaction = (0, import_compat.fromVersionedTransaction)(result);
+    return responseTransaction;
+  }
+  async signAllTransactions(transactions) {
+    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 versionedTransactions = transactions.map(
+      (transaction) => transactionToVersionedTransaction(transaction)
+    );
+    const result = await provider.signAllTransactions(versionedTransactions);
+    const responseTransactions = result.map((transaction) => (0, import_compat.fromVersionedTransaction)(transaction));
+    return responseTransactions;
+  }
+};
+_getProvider = new WeakSet();
+getProvider_fn = function() {
+  return window?.phantom?.solana;
+};
+
+// src/solana/strategies/deeplinks.ts
+var DeepLinkSolanaStrategy = class {
+  constructor() {
+    this.type = "deeplink" /* DEEPLINK */;
+  }
+  load() {
+    return Promise.resolve(this);
+  }
+  get isConnected() {
+    return true;
+  }
+  async connect({ onlyIfTrusted }) {
+    const deeplink = `phantom://connect?onlyIfTrusted=${onlyIfTrusted}`;
+    window.location.href = deeplink;
+    return Promise.resolve(void 0);
+  }
+  async disconnect() {
+    const deeplink = `phantom://disconnect`;
+    window.location.href = deeplink;
+    return Promise.resolve();
+  }
+  async getAccount() {
+    const deeplink = `phantom://account`;
+    window.location.href = deeplink;
+    return Promise.resolve(void 0);
+  }
+  async signMessage(message, display) {
+    const messageEncoded = Buffer.from(message).toString("base64");
+    const deeplink = `phantom://sign-message?message=${messageEncoded}&display=${display}`;
+    window.location.href = deeplink;
+    return Promise.resolve({
+      signature: new Uint8Array(),
+      address: ""
+    });
+  }
+  async signIn(signInData) {
+    const deeplink = `phantom://sign-in?signInData=${encodeURIComponent(JSON.stringify(signInData))}`;
+    window.location.href = deeplink;
+    return Promise.resolve({
+      address: "",
+      signature: new Uint8Array(),
+      signedMessage: new Uint8Array()
+    });
+  }
+  async signAndSendTransaction(transaction) {
+    const deeplink = `phantom://sign-and-send-transaction?transaction=${transaction}`;
+    window.location.href = deeplink;
+    return Promise.resolve({
+      signature: "",
+      address: ""
+    });
+  }
+  async signTransaction(transaction) {
+    const deeplink = `phantom://sign-transaction?transaction=${transaction}`;
+    window.location.href = deeplink;
+    return Promise.resolve(transaction);
+  }
+  async signAllTransactions(transactions) {
+    const deeplink = `phantom://sign-all-transactions?transactions=${transactions}`;
+    window.location.href = deeplink;
+    return Promise.resolve(transactions);
+  }
+};
+
+// src/solana/getProvider.ts
+async function getProvider(strategy = "injected" /* INJECTED */) {
+  if (strategy === "injected") {
+    const provider = new InjectedSolanaStrategy();
+    try {
+      await provider.load();
+      return provider;
+    } catch (error) {
+      throw new Error("Provider not found.");
+    }
+  } else if (strategy === "deeplink") {
+    return new DeepLinkSolanaStrategy();
+  } else {
+    throw new Error("Invalid provider type.");
+  }
+}
+
+// src/solana/eventListeners.ts
+var eventCallbacks = /* @__PURE__ */ new Map();
+function addEventListener(event, callback) {
+  if (!eventCallbacks.has(event)) {
+    eventCallbacks.set(event, /* @__PURE__ */ new Set());
+  }
+  eventCallbacks.get(event).add(callback);
+  return () => {
+    removeEventListener(event, callback);
+  };
+}
+function removeEventListener(event, callback) {
+  if (eventCallbacks.has(event)) {
+    eventCallbacks.get(event).delete(callback);
+    if (eventCallbacks.get(event).size === 0) {
+      eventCallbacks.delete(event);
+    }
+  }
+}
+function triggerEvent(event, ...args) {
+  if (eventCallbacks.has(event)) {
+    eventCallbacks.get(event).forEach((cb) => {
+      if (event === "connect" && args[0] && typeof args[0] === "string") {
+        cb(args[0]);
+      } else if (event === "disconnect") {
+        cb();
+      } else if (event === "accountChanged" && args[0] && typeof args[0] === "string") {
+        cb(args[0]);
+      }
+    });
+  }
+}
+
+// src/solana/connect.ts
+async function connect() {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (provider.isConnected) {
+    return provider.getAccount();
+  }
+  try {
+    const address = await provider.connect({ onlyIfTrusted: true });
+    if (address) {
+      triggerEvent("connect", address);
+      return address;
+    }
+  } catch (error) {
+  }
+  try {
+    const address = await provider.connect({ onlyIfTrusted: false });
+    if (address) {
+      triggerEvent("connect", address);
+      return address;
+    }
+  } catch (error) {
+  }
+  throw new Error("Failed to connect to Phantom.");
+}
+
+// src/solana/disconnect.ts
+async function disconnect() {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  await provider.disconnect();
+  triggerEvent("disconnect");
+}
+
+// src/solana/getAccount.ts
+async function getAccount() {
+  const provider = await getProvider();
+  return provider.getAccount();
+}
+
+// src/solana/signAndSendTransaction.ts
+var import_compat2 = require("@solana/compat");
+async function signAndSendTransaction(transaction) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (!provider.isConnected) {
+    await provider.connect({ onlyIfTrusted: false });
+  }
+  let kitTransaction;
+  if (transaction?.messageBytes == null) {
+    kitTransaction = (0, import_compat2.fromVersionedTransaction)(transaction);
+  } else {
+    kitTransaction = transaction;
+  }
+  return provider.signAndSendTransaction(kitTransaction);
+}
+
+// src/solana/signIn.ts
+async function signIn(signInData) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  const result = await provider.signIn(signInData);
+  if (result.address) {
+    triggerEvent("connect", result.address);
+  }
+  return result;
+}
+
+// src/solana/signMessage.ts
+async function signMessage(message, display) {
+  const provider = await getProvider();
+  if (!provider) {
+    throw new Error("Provider not found.");
+  }
+  if (!provider.isConnected) {
+    await provider.connect({ onlyIfTrusted: false });
+  }
+  return provider.signMessage(message, display);
+}
+
+// src/solana/plugin.ts
+var solana = {
+  connect,
+  disconnect,
+  getAccount,
+  signMessage,
+  signIn,
+  signAndSendTransaction,
+  addEventListener,
+  removeEventListener
+};
+function createSolanaPlugin() {
+  return {
+    name: "solana",
+    create: () => solana
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSolanaPlugin
+});