@phantom/browser-injected-sdk 1.0.0-beta.9 → 1.0.2

package/dist/index.js

@@ -36,6 +36,7 @@ __export(src_exports, {
   createEthereumPlugin: () => createEthereumPlugin,
   createExtensionPlugin: () => createExtensionPlugin,
   createPhantom: () => createPhantom,
+  createSiweMessage: () => createSiweMessage,
   isPhantomExtensionInstalled: () => isInstalled
 });
 module.exports = __toCommonJS(src_exports);
@@ -61,6 +62,129 @@ function createExtensionPlugin() {
   };
 }
 
+// src/ethereum/siwe.ts
+var ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+var DOMAIN_REGEX = /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}(:[0-9]{1,5})?$/;
+var IP_REGEX = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(:[0-9]{1,5})?$/;
+var LOCALHOST_REGEX = /^localhost(:[0-9]{1,5})?$/;
+var NONCE_REGEX = /^[a-zA-Z0-9]{8,}$/;
+var SCHEME_REGEX = /^([a-zA-Z][a-zA-Z0-9+-.]*)$/;
+function createSiweMessage({
+  address,
+  chainId,
+  domain,
+  nonce,
+  uri,
+  version,
+  scheme,
+  statement: _statement,
+  requestId,
+  resources,
+  issuedAt = /* @__PURE__ */ new Date(),
+  expirationTime,
+  notBefore
+}) {
+  if (!ADDRESS_REGEX.test(address)) {
+    throw new Error("address must be a hex value of 20 bytes (40 hex characters).");
+  }
+  if (chainId !== Math.floor(chainId)) {
+    throw new Error("chainId must be a EIP-155 chain ID.");
+  }
+  if (!(DOMAIN_REGEX.test(domain) || IP_REGEX.test(domain) || LOCALHOST_REGEX.test(domain))) {
+    throw new Error("domain must be an RFC 3986 authority.");
+  }
+  if (!NONCE_REGEX.test(nonce)) {
+    throw new Error("nonce must be at least 8 characters.");
+  }
+  if (!_isUri(uri)) {
+    throw new Error("uri must be a RFC 3986 URI referring to the resource that is the subject of the signing.");
+  }
+  if (version !== "1") {
+    throw new Error("version must be '1'.");
+  }
+  if (scheme && !SCHEME_REGEX.test(scheme)) {
+    throw new Error("scheme must be an RFC 3986 URI scheme.");
+  }
+  if (_statement?.includes("\n")) {
+    throw new Error("statement must not include '\\n'.");
+  }
+  const origin = scheme ? `${scheme}://${domain}` : domain;
+  const statement = _statement ? `${_statement}
+` : "";
+  const prefix = `${origin} wants you to sign in with your Ethereum account:
+${address}
+
+${statement}`;
+  let suffix = `URI: ${uri}
+Version: ${version}
+Chain ID: ${chainId}
+Nonce: ${nonce}
+Issued At: ${issuedAt.toISOString()}`;
+  if (expirationTime) {
+    suffix += `
+Expiration Time: ${expirationTime.toISOString()}`;
+  }
+  if (notBefore) {
+    suffix += `
+Not Before: ${notBefore.toISOString()}`;
+  }
+  if (requestId) {
+    suffix += `
+Request ID: ${requestId}`;
+  }
+  if (resources) {
+    let content = "\nResources:";
+    for (const resource of resources) {
+      if (!_isUri(resource)) {
+        throw new Error("resources must be RFC 3986 URIs.");
+      }
+      content += `
+- ${resource}`;
+    }
+    suffix += content;
+  }
+  return `${prefix}
+${suffix}`;
+}
+function _isUri(value) {
+  if (/[^a-z0-9:/?#[\]@!$&'()*+,;=.\-_~%]/i.test(value))
+    return false;
+  if (/%[^0-9a-f]/i.test(value))
+    return false;
+  if (/%[0-9a-f](:?[^0-9a-f]|$)/i.test(value))
+    return false;
+  const splitted = splitUri(value);
+  const scheme = splitted[1];
+  const authority = splitted[2];
+  const path = splitted[3];
+  const query = splitted[4];
+  const fragment = splitted[5];
+  if (!(scheme?.length && path.length >= 0))
+    return false;
+  if (authority?.length) {
+    if (!(path.length === 0 || /^\//.test(path)))
+      return false;
+  } else {
+    if (/^\/\//.test(path))
+      return false;
+  }
+  if (!/^[a-z][a-z0-9+\-.]*$/.test(scheme.toLowerCase()))
+    return false;
+  let out = "";
+  out += `${scheme}:`;
+  if (authority?.length)
+    out += `//${authority}`;
+  out += path;
+  if (query?.length)
+    out += `?${query}`;
+  if (fragment?.length)
+    out += `#${fragment}`;
+  return out;
+}
+function splitUri(value) {
+  return value.match(/(?:([^:/?#]+):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/);
+}
+
 // src/ethereum/strategies/injected.ts
 var MAX_RETRIES = 4;
 var BASE_DELAY = 100;
@@ -177,7 +301,7 @@ var InjectedEthereumStrategy = class {
     if (!provider) {
       throw new Error("Provider not found.");
     }
-    const message = `Sign in to ${signInData.domain || "this application"}`;
+    const message = createSiweMessage(signInData);
     const address = provider.selectedAddress;
     if (!address) {
       throw new Error("No address available.");
@@ -273,7 +397,7 @@ function addEventListener(event, callback) {
     eventListeners.set(event, /* @__PURE__ */ new Set());
   }
   const listeners = eventListeners.get(event);
-  listeners.add(callback);
+  listeners?.add(callback);
   return () => removeEventListener(event, callback);
 }
 function removeEventListener(event, callback) {
@@ -347,16 +471,6 @@ async function 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) {
@@ -378,18 +492,6 @@ async function signTypedData(typedData, address) {
   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();
@@ -429,47 +531,122 @@ async function switchChain(chainId) {
 }
 
 // src/ethereum/plugin.ts
-var ethereum = {
-  connect,
-  disconnect,
-  getAccounts,
-  signMessage,
-  signPersonalMessage,
-  signTypedData,
-  signIn,
-  sendTransaction,
-  signTransaction,
-  getChainId,
-  switchChain,
-  getProvider,
-  addEventListener,
-  removeEventListener
-};
-async function bindProviderEvents() {
-  try {
-    const strategy = await getProvider();
-    const provider = strategy.getProvider();
-    if (provider) {
-      provider.on("connect", () => {
-        provider.request({ method: "eth_accounts" }).then((accounts) => {
-          if (accounts?.length > 0)
+var Ethereum = class {
+  constructor() {
+    this._chainId = "0x1";
+    this._accounts = [];
+    this.bindProviderEvents();
+  }
+  get connected() {
+    return this._accounts.length > 0;
+  }
+  get chainId() {
+    return this._chainId;
+  }
+  get accounts() {
+    return this._accounts;
+  }
+  async request(args) {
+    const provider = await getProvider();
+    if (!provider) {
+      throw new Error("Provider not found.");
+    }
+    const providerInstance = provider.getProvider();
+    if (!providerInstance) {
+      throw new Error("Provider instance not found.");
+    }
+    return providerInstance.request(args);
+  }
+  async connect() {
+    const accounts = await connect();
+    this._accounts = accounts;
+    return accounts;
+  }
+  async disconnect() {
+    await disconnect();
+    this._accounts = [];
+  }
+  signPersonalMessage(message, address) {
+    return signPersonalMessage(message, address);
+  }
+  signTypedData(data, address) {
+    return signTypedData(data, address);
+  }
+  signTransaction(transaction) {
+    return signTransaction(transaction);
+  }
+  sendTransaction(transaction) {
+    return sendTransaction(transaction);
+  }
+  async switchChain(chainId) {
+    const hexChainId = typeof chainId === "string" ? chainId.toLowerCase().startsWith("0x") ? chainId.toLowerCase() : `0x${parseInt(chainId, 10).toString(16)}` : `0x${chainId.toString(16)}`;
+    await switchChain(hexChainId);
+    this._chainId = hexChainId;
+  }
+  async getChainId() {
+    const chainId = await getChainId();
+    const parsed = parseInt(chainId, 16);
+    this._chainId = chainId;
+    return parsed;
+  }
+  async getAccounts() {
+    const accounts = await getAccounts();
+    this._accounts = accounts;
+    return accounts;
+  }
+  isConnected() {
+    return this._accounts.length > 0;
+  }
+  on(event, listener) {
+    addEventListener(event, listener);
+  }
+  off(event, listener) {
+    removeEventListener(event, listener);
+  }
+  async bindProviderEvents() {
+    try {
+      const strategy = await getProvider();
+      const provider = strategy.getProvider();
+      if (provider) {
+        provider.on("connect", async () => {
+          try {
+            const accounts = await provider.request({ method: "eth_accounts" });
+            if (accounts?.length > 0) {
+              this._accounts = accounts;
+              triggerEvent("connect", accounts);
+            }
+          } catch {
+          }
+        });
+        provider.on("disconnect", () => {
+          this._accounts = [];
+          const error = {
+            code: 4900,
+            message: "Provider disconnected"
+          };
+          triggerEvent("disconnect", error);
+        });
+        provider.on("accountsChanged", (accounts) => {
+          this._accounts = accounts;
+          triggerEvent("accountsChanged", accounts);
+          if (accounts && accounts.length > 0) {
             triggerEvent("connect", accounts);
-        }).catch(() => {
+          }
         });
-      });
-      provider.on("disconnect", () => triggerEvent("disconnect", []));
-      provider.on("accountsChanged", (accounts) => triggerEvent("accountsChanged", accounts));
-      provider.on("chainChanged", (chainId) => triggerEvent("chainChanged", chainId));
+        provider.on("chainChanged", (chainId) => {
+          this._chainId = chainId;
+          triggerEvent("chainChanged", chainId);
+        });
+      }
+    } catch (error) {
     }
-  } catch (error) {
   }
-}
+};
 function createEthereumPlugin() {
   return {
     name: "ethereum",
     create: () => {
-      bindProviderEvents();
-      return ethereum;
+      return new Ethereum();
     }
   };
 }
@@ -487,5 +664,6 @@ function createPhantom({ plugins = [] }) {
   createEthereumPlugin,
   createExtensionPlugin,
   createPhantom,
+  createSiweMessage,
   isPhantomExtensionInstalled
 });

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import {
-  createEthereumPlugin
-} from "./chunk-MDTCVDFZ.mjs";
+  createEthereumPlugin,
+  createSiweMessage
+} from "./chunk-CS23VDDD.mjs";
 import "./chunk-WUKYLWAZ.mjs";
 import "./chunk-GV6AIHPN.mjs";
 
@@ -37,5 +38,6 @@ export {
   createEthereumPlugin,
   createExtensionPlugin,
   createPhantom,
+  createSiweMessage,
   isInstalled as isPhantomExtensionInstalled
 };

package/dist/solana/index.d.ts

@@ -1,11 +1,5 @@
-import { P as Plugin } from '../index-3a750f13.js';
-import { VersionedTransaction, Transaction } from '@phantom/sdk-types';
-
-declare function connect({ onlyIfTrusted }?: {
-    onlyIfTrusted?: boolean | undefined;
-}): Promise<string | undefined>;
-
-declare function disconnect(): Promise<void>;
+import { P as Plugin } from '../index-673af1e4.js';
+import { ISolanaChain } from '@phantom/chain-interfaces';
 
 type SendOptions = {
     skipPreflight?: boolean;
@@ -32,7 +26,6 @@ type SolanaSignInData = {
     resources?: string[];
 };
 type DisplayEncoding = "utf8" | "hex";
-type PhantomEventType = "connect" | "disconnect" | "accountChanged";
 interface PhantomSolanaProvider {
     isPhantom: boolean;
     publicKey: PublicKey | null;
@@ -66,94 +59,12 @@ interface PhantomSolanaProvider {
     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 (Web3.js format).
- * @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: VersionedTransaction | Transaction): Promise<{
-    signature: string;
-    address?: string;
-}>;
-
-/**
- * Signs and sends all transactions using the Phantom provider.
- * @param transactions An array of transactions to sign and send (Web3.js format).
- * @returns A promise that resolves with an array of transaction signatures and optionally the public key.
- * @throws Error if Phantom provider is not found or if the operation fails.
- */
-declare function signAndSendAllTransactions(transactions: (VersionedTransaction | Transaction)[]): Promise<{
-    signatures: string[];
-    address?: string;
-}>;
-
-/**
- * Signs a transaction using the Phantom provider without sending it.
- * @param transaction The transaction to sign (Web3.js format).
- * @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: VersionedTransaction | Transaction): Promise<VersionedTransaction | Transaction>;
-
-/**
- * Signs all transactions using the Phantom provider.
- * @param transactions An array of transactions to sign (Web3.js format).
- * @returns A promise that resolves with an array of signed transactions.
- * @throws Error if Phantom provider is not found or if the operation fails.
- */
-declare function signAllTransactions(transactions: (VersionedTransaction | Transaction)[]): Promise<(VersionedTransaction | Transaction)[]>;
-
-/**
- * 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;
-    signTransaction: typeof signTransaction;
-    signAllTransactions: typeof signAllTransactions;
-    signAndSendTransaction: typeof signAndSendTransaction;
-    signAndSendAllTransactions: typeof signAndSendAllTransactions;
-    addEventListener: (event: PhantomEventType, callback: PhantomEventCallback) => () => void;
-    removeEventListener: (event: PhantomEventType, callback: PhantomEventCallback) => void;
-};
-declare function createSolanaPlugin(): Plugin<Solana>;
+declare function createSolanaPlugin(): Plugin<ISolanaChain>;
 
 declare module "../index" {
     interface Phantom {
-        solana: Solana;
+        solana: ISolanaChain;
     }
 }
 
-export { PhantomSolanaProvider, Solana, SolanaSignInData, createSolanaPlugin };
+export { PhantomSolanaProvider, SolanaSignInData, createSolanaPlugin };

package/dist/solana/index.js

@@ -212,28 +212,26 @@ function addEventListener(event, callback) {
   if (!eventCallbacks.has(event)) {
     eventCallbacks.set(event, /* @__PURE__ */ new Set());
   }
-  eventCallbacks.get(event).add(callback);
+  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.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]);
+    eventCallbacks.get(event)?.forEach((cb) => {
+      try {
+        cb(...args);
+      } catch (error) {
+        console.error(`Error in ${event} event listener:`, error);
       }
     });
   }
@@ -334,19 +332,6 @@ async function signAllTransactions(transactions) {
   return provider.signAllTransactions(transactions);
 }
 
-// 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();
@@ -360,43 +345,112 @@ async function signMessage(message, display) {
 }
 
 // src/solana/plugin.ts
-var solana = {
-  connect,
-  disconnect,
-  getAccount,
-  signMessage,
-  signIn,
-  signTransaction,
-  signAllTransactions,
-  signAndSendTransaction,
-  signAndSendAllTransactions,
-  addEventListener,
-  removeEventListener
-};
-async function bindProviderEvents() {
-  try {
-    const strategy = await getProvider();
-    const provider = strategy.getProvider();
-    if (provider) {
-      provider.on("connect", (publicKey) => {
-        if (publicKey)
-          triggerEvent("connect", publicKey.toString());
-      });
-      provider.on("disconnect", () => triggerEvent("disconnect"));
-      provider.on("accountChanged", (publicKey) => {
-        if (publicKey)
-          triggerEvent("accountChanged", publicKey.toString());
-      });
+var Solana = class {
+  constructor() {
+    this._publicKey = null;
+    this.bindProviderEvents();
+  }
+  get publicKey() {
+    return this._publicKey;
+  }
+  get connected() {
+    return this._publicKey !== null;
+  }
+  async connect(options) {
+    const address = await connect(options);
+    if (!address) {
+      throw new Error("Failed to connect to Solana wallet");
     }
-  } catch (error) {
+    this._publicKey = address;
+    return { publicKey: address };
   }
-}
+  async disconnect() {
+    await disconnect();
+    this._publicKey = null;
+  }
+  async signMessage(message) {
+    const messageBytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+    const result = await signMessage(messageBytes);
+    return {
+      signature: result.signature instanceof Uint8Array ? result.signature : new Uint8Array(result.signature),
+      publicKey: result.address || this._publicKey || ""
+    };
+  }
+  signTransaction(transaction) {
+    return signTransaction(transaction);
+  }
+  async signAndSendTransaction(transaction) {
+    const result = await signAndSendTransaction(transaction);
+    return { signature: result.signature };
+  }
+  signAllTransactions(transactions) {
+    return signAllTransactions(transactions);
+  }
+  async signAndSendAllTransactions(transactions) {
+    const result = await signAndSendAllTransactions(transactions);
+    return { signatures: result.signatures };
+  }
+  async switchNetwork(_network) {
+    return Promise.resolve();
+  }
+  async getPublicKey() {
+    if (this._publicKey) {
+      return this._publicKey;
+    }
+    try {
+      const account = await getAccount();
+      this._publicKey = account || null;
+      return this._publicKey;
+    } catch {
+      return null;
+    }
+  }
+  isConnected() {
+    return this._publicKey !== null;
+  }
+  on(event, listener) {
+    addEventListener(event, listener);
+  }
+  off(event, listener) {
+    removeEventListener(event, listener);
+  }
+  async bindProviderEvents() {
+    try {
+      const strategy = await getProvider();
+      const provider = strategy.getProvider();
+      if (provider) {
+        provider.on("connect", (publicKey) => {
+          if (publicKey) {
+            const pubKey = publicKey.toString();
+            this._publicKey = pubKey;
+            triggerEvent("connect", pubKey);
+          }
+        });
+        provider.on("disconnect", () => {
+          this._publicKey = null;
+          triggerEvent("disconnect");
+        });
+        provider.on("accountChanged", (publicKey) => {
+          if (publicKey) {
+            const pubKey = publicKey.toString();
+            this._publicKey = pubKey;
+            triggerEvent("accountChanged", pubKey);
+            triggerEvent("connect", pubKey);
+          } else {
+            this._publicKey = null;
+            triggerEvent("accountChanged", null);
+          }
+        });
+      }
+    } catch (error) {
+    }
+  }
+};
 function createSolanaPlugin() {
   return {
     name: "solana",
     create: () => {
-      bindProviderEvents();
-      return solana;
+      return new Solana();
     }
   };
 }