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

package/dist/auto-confirm/index.d.ts

@@ -1,5 +1,6 @@
-import { P as Plugin } from '../index-3a750f13.js';
+import { P as Plugin } from '../index-673af1e4.js';
 import { NetworkId } from '@phantom/constants';
+import '@phantom/chain-interfaces';
 
 type AutoConfirmEnableParams = {
     chains?: NetworkId[];

package/dist/{chunk-MDTCVDFZ.mjs → chunk-CS23VDDD.mjs}

@@ -3,6 +3,129 @@ import {
   __privateMethod
 } from "./chunk-GV6AIHPN.mjs";
 
+// 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;
@@ -119,7 +242,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.");
@@ -215,7 +338,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) {
@@ -289,16 +412,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) {
@@ -320,18 +433,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();
@@ -371,51 +472,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();
     }
   };
 }
 
 export {
+  createSiweMessage,
   createEthereumPlugin
 };

package/dist/ethereum/index.d.ts

@@ -1 +1,2 @@
-export { E as Ethereum, e as EthereumEventType, d as EthereumSignInData, b as EthereumTransaction, a as PhantomEthereumProvider, c as createEthereumPlugin } from '../index-3a750f13.js';
+export { e as EthereumEventType, d as EthereumSignInData, E as EthereumTransaction, b as PhantomEthereumProvider, c as createEthereumPlugin, a as createSiweMessage } from '../index-673af1e4.js';
+import '@phantom/chain-interfaces';