@phantom/browser-injected-sdk 1.0.0 → 1.0.3

package/dist/ethereum/index.mjs

@@ -1,8 +1,10 @@
 import {
-  createEthereumPlugin
-} from "../chunk-MDTCVDFZ.mjs";
+  createEthereumPlugin,
+  createSiweMessage
+} from "../chunk-JJH6SEIK.mjs";
 import "../chunk-WUKYLWAZ.mjs";
 import "../chunk-GV6AIHPN.mjs";
 export {
-  createEthereumPlugin
+  createEthereumPlugin,
+  createSiweMessage
 };

package/dist/index-673af1e4.d.ts

@@ -0,0 +1,93 @@
+import { IEthereumChain } from '@phantom/chain-interfaces';
+
+declare function isInstalled(): boolean;
+
+type Extension = {
+    isInstalled: typeof isInstalled;
+};
+declare function createExtensionPlugin(): Plugin<Extension>;
+
+declare module "../index" {
+    interface Phantom {
+        extension: Extension;
+    }
+}
+
+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 = {
+    address: `0x${string}`;
+    chainId: number;
+    domain: string;
+    expirationTime?: Date | undefined;
+    issuedAt?: Date | undefined;
+    nonce: string;
+    notBefore?: Date | undefined;
+    requestId?: string | undefined;
+    resources?: Array<string> | undefined;
+    scheme?: string | undefined;
+    statement?: string | undefined;
+    uri: string;
+    version: "1";
+};
+type EthereumEventType = "connect" | "disconnect" | "accountsChanged" | "chainChanged";
+interface PhantomEthereumProvider {
+    isPhantom: boolean;
+    selectedAddress: string | null;
+    chainId: string;
+    isConnected: boolean;
+    request: <T = any>(args: {
+        method: string;
+        params?: any[];
+    }) => Promise<T>;
+    on: (event: EthereumEventType, handler: (...args: any[]) => void) => void;
+    off: (event: EthereumEventType, handler: (...args: any[]) => void) => void;
+    removeAllListeners: (event?: EthereumEventType) => void;
+}
+
+declare function createEthereumPlugin(): Plugin<IEthereumChain>;
+
+/**
+ * Creates an EIP-4361 Sign In With Ethereum message.
+ *
+ * Adapted from viem's createSiweMessage implementation:
+ * https://github.com/wevm/viem/blob/53d302049e166706fecde453ea984284dd180ca6/src/utils/siwe/createSiweMessage.ts
+ *
+ * Copyright (c) 2023-present weth, LLC
+ * Licensed under the MIT License.
+ */
+declare function createSiweMessage({ address, chainId, domain, nonce, uri, version, scheme, statement: _statement, requestId, resources, issuedAt, expirationTime, notBefore, }: EthereumSignInData): string;
+
+declare module "../index" {
+    interface Phantom {
+        ethereum: IEthereumChain;
+    }
+}
+
+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, createSiweMessage as a, PhantomEthereumProvider as b, createEthereumPlugin as c, EthereumSignInData as d, EthereumEventType as e, Phantom as f, createPhantom as g, createExtensionPlugin as h, Extension as i, isInstalled as j };

package/dist/index.d.ts

@@ -1 +1,2 @@
-export { C as CreatePhantomConfig, i as Extension, f as Phantom, P as Plugin, c as createEthereumPlugin, h as createExtensionPlugin, g as createPhantom, j as isPhantomExtensionInstalled } from './index-3a750f13.js';
+export { C as CreatePhantomConfig, i as Extension, f as Phantom, P as Plugin, c as createEthereumPlugin, h as createExtensionPlugin, g as createPhantom, a as createSiweMessage, j as isPhantomExtensionInstalled } from './index-673af1e4.js';
+import '@phantom/chain-interfaces';

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,119 @@ 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 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 +661,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-JJH6SEIK.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 };