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

package/dist/ethereum/index.js

@@ -33,10 +33,134 @@ var __privateMethod = (obj, member, method) => {
 // src/ethereum/index.ts
 var ethereum_exports = {};
 __export(ethereum_exports, {
-  createEthereumPlugin: () => createEthereumPlugin
+  createEthereumPlugin: () => createEthereumPlugin,
+  createSiweMessage: () => createSiweMessage
 });
 module.exports = __toCommonJS(ethereum_exports);
 
+// 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;
@@ -153,7 +277,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.");
@@ -249,7 +373,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) {
@@ -323,16 +447,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) {
@@ -354,18 +468,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();
@@ -405,51 +507,127 @@ 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();
     }
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createEthereumPlugin
+  createEthereumPlugin,
+  createSiweMessage
 });

package/dist/ethereum/index.mjs

@@ -1,8 +1,10 @@
 import {
-  createEthereumPlugin
-} from "../chunk-MDTCVDFZ.mjs";
+  createEthereumPlugin,
+  createSiweMessage
+} from "../chunk-CS23VDDD.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';