@phantom/browser-injected-sdk 0.0.9

package/dist/solana/index.mjs

@@ -0,0 +1,379 @@
+import "../chunk-WUKYLWAZ.mjs";
+import {
+  __privateAdd,
+  __privateMethod
+} from "../chunk-GV6AIHPN.mjs";
+
+// src/solana/utils/transactionToVersionedTransaction.ts
+import { getTransactionEncoder } from "@solana/transactions";
+function transactionToVersionedTransaction(transaction) {
+  const serialized = getTransactionEncoder().encode(transaction);
+  const fakeVersioned = {
+    serialize() {
+      return new Uint8Array(serialized);
+    }
+  };
+  return fakeVersioned;
+}
+
+// src/solana/strategies/injected.ts
+import { fromVersionedTransaction } from "@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 = 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) => 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
+import { fromVersionedTransaction as fromVersionedTransaction2 } from "@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 = fromVersionedTransaction2(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
+  };
+}
+export {
+  createSolanaPlugin
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@phantom/browser-injected-sdk",
+  "version": "0.0.9",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./solana": {
+      "import": "./dist/solana/index.mjs",
+      "require": "./dist/solana/index.js",
+      "types": "./dist/solana/index.d.ts"
+    },
+    "./auto-confirm": {
+      "import": "./dist/auto-confirm/index.mjs",
+      "require": "./dist/auto-confirm/index.js",
+      "types": "./dist/auto-confirm/index.d.ts"
+    },
+    "./ethereum": {
+      "import": "./dist/ethereum/index.mjs",
+      "require": "./dist/ethereum/index.js",
+      "types": "./dist/ethereum/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "?pack-release": "When https://github.com/changesets/changesets/issues/432 has a solution we can remove this trick",
+    "pack-release": "rimraf ./_release && yarn pack && mkdir ./_release && tar zxvf ./package.tgz --directory ./_release && rm ./package.tgz",
+    "build": "rimraf ./dist && tsup src/index.ts src/solana/index.ts src/auto-confirm/index.ts src/ethereum/index.ts --format cjs,esm --dts",
+    "build:watch": "rimraf ./dist && tsup src/index.ts src/solana/index.ts src/auto-confirm/index.ts src/ethereum/index.ts --format cjs,esm --dts --watch",
+    "dev": "rimraf ./dist && tsup src/index.ts src/solana/index.ts src/auto-confirm/index.ts src/ethereum/index.ts --format cjs,esm --dts --watch",
+    "lint": "tsc --noEmit && eslint --cache . --ext .ts,.tsx",
+    "test": "jest",
+    "prettier": "prettier --write \"src/**/*.{ts,tsx}\""
+  },
+  "devDependencies": {
+    "@solana/web3.js": "^1.98.2",
+    "@types/jest": "^29.5.14",
+    "eslint": "8.53.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.2",
+    "rimraf": "^6.0.1",
+    "tsup": "^6.7.0",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "@solana/compat": "2.1.1",
+    "@solana/kit": "^2.1.1",
+    "@solana/transactions": "^2.1.1"
+  },
+  "publishConfig": {
+    "directory": "_release/package"
+  }
+}