streamlit-browser-web3 0.1.0__tar.gz

streamlit_browser_web3-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

streamlit_browser_web3-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: streamlit-browser-web3
+Version: 0.1.0
+Summary: Streamlit components and helpers for browser-injected EIP-1193 provider utility.
+Project-URL: Homepage, https://github.com/luismasuelli/streamlit-browser-web3
+Project-URL: Repository, https://github.com/luismasuelli/streamlit-browser-web3
+Keywords: streamlit,web3,ethereum,eip-1193,metamask
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: streamlit>=1.36
+Dynamic: license-file
+
+# streamlit-web3
+
+`streamlit-web3` packages a hidden Streamlit component that bridges a browser-injected EIP-1193 wallet provider into
+Web3.py.
+
+## Install
+
+```bash
+pip install streamlit-web3
+```
+
+## Minimal usage
+
+```python
+import streamlit as st
+
+from streamlit_browser_web3 import wallet_get
+
+handler = wallet_get()
+if handler.status == "connected":
+    if st.button("Disconnect your wallet"):
+        handler.disconnect()
+    page_body(handler)
+else:
+    if st.button("Connect your wallet"):
+        handler.connect()
+```
+
+## Important Streamlit behavior
+
+Wallet operations are asynchronous in the browser but Streamlit scripts are synchronous and rerun-driven.
+
+- `wallet_get()` must be rendered on every rerun.
+- A wallet request may complete over multiple reruns.
+- For button-triggered Web3 calls, persist the user intent in `st.session_state` until the call returns.
+- Requests are serialized through the hidden browser bridge.
+
+Chain metadata and ERC-20 helper code are intentionally kept in the example app, not in the package.
+
+## Handler API
+
+`wallet_get()` returns a `WalletHandler` instance. Render it on every rerun and use the same handler object as your app's wallet state interface.
+
+### State properties
+
+- `handler.status`: One of `"not-available"`, `"disconnected"`, or `"connected"`.
+- `handler.available`: `True` when an injected browser provider such as `window.ethereum` exists.
+- `handler.connected`: `True` when the wallet is connected and at least one account is available.
+- `handler.accounts`: List of currently exposed account addresses.
+- `handler.chain_id`: Current chain id as an `int`, or `None`.
+- `handler.chain_id_hex`: Current chain id as a hex string such as `"0x1"`, or `None`.
+- `handler.busy`: `True` while a connect/disconnect action or an interactive wallet request is still pending.
+- `handler.last_error`: Last wallet or bridge error message, if any.
+- `handler.snapshot`: Raw snapshot dictionary returned by the hidden browser component.
+
+### Methods
+
+- `handler.connect()`: Starts the wallet connection flow and reruns the Streamlit script.
+- `handler.disconnect()`: Starts the wallet disconnect flow and reruns the Streamlit script.
+- `handler.request(method, params=None, *, key)`: Sends an EIP-1193 request and returns `(status, result)`.
+- `handler.forget(key)`: Removes a tracked request so the same key can be reused for a new flow.
+- `handler.snapshot_view()`: Returns a typed `WalletSnapshot` dataclass with the main handler fields.
+
+### `request()` status values
+
+`handler.request(...)` returns a `(status, result)` tuple:
+
+- `"pending"`: The wallet request is still waiting for completion in the browser.
+- `"success"`: The request completed successfully and `result` contains the returned value.
+- `"error"`: The request failed and `result` contains an error message.
+
+The `key` argument is required. Requests are tracked by key across reruns, which lets button-triggered flows continue until the browser returns a result.
+
+### Supported request methods
+
+The handler has built-in support for these immediate methods, which resolve from the current snapshot without opening a wallet prompt:
+
+- `eth_accounts`
+- `eth_chainId`
+- `eth_coinbase`
+- `net_version`
+
+The handler also marks these methods as interactive, meaning they can leave `handler.busy == True` while the wallet is waiting for user confirmation:
+
+- `eth_requestAccounts`
+- `eth_sendTransaction`
+- `eth_sign`
+- `eth_signTransaction`
+- `eth_signTypedData`
+- `eth_signTypedData_v1`
+- `eth_signTypedData_v3`
+- `eth_signTypedData_v4`
+- `personal_sign`
+- `wallet_addEthereumChain`
+- `wallet_requestPermissions`
+- `wallet_revokePermissions`
+- `wallet_switchEthereumChain`
+
+Other provider methods can still be passed to `handler.request(...)`. They are tracked as non-interactive requests unless they are in the interactive list above.
+
+## Build
+
+```bash
+python -m build
+```
+
+## Example app
+
+An end-to-end example is included at `examples/streamlit_app.py`.

streamlit_browser_web3-0.1.0/README.md

@@ -0,0 +1,109 @@
+# streamlit-web3
+
+`streamlit-web3` packages a hidden Streamlit component that bridges a browser-injected EIP-1193 wallet provider into
+Web3.py.
+
+## Install
+
+```bash
+pip install streamlit-web3
+```
+
+## Minimal usage
+
+```python
+import streamlit as st
+
+from streamlit_browser_web3 import wallet_get
+
+handler = wallet_get()
+if handler.status == "connected":
+    if st.button("Disconnect your wallet"):
+        handler.disconnect()
+    page_body(handler)
+else:
+    if st.button("Connect your wallet"):
+        handler.connect()
+```
+
+## Important Streamlit behavior
+
+Wallet operations are asynchronous in the browser but Streamlit scripts are synchronous and rerun-driven.
+
+- `wallet_get()` must be rendered on every rerun.
+- A wallet request may complete over multiple reruns.
+- For button-triggered Web3 calls, persist the user intent in `st.session_state` until the call returns.
+- Requests are serialized through the hidden browser bridge.
+
+Chain metadata and ERC-20 helper code are intentionally kept in the example app, not in the package.
+
+## Handler API
+
+`wallet_get()` returns a `WalletHandler` instance. Render it on every rerun and use the same handler object as your app's wallet state interface.
+
+### State properties
+
+- `handler.status`: One of `"not-available"`, `"disconnected"`, or `"connected"`.
+- `handler.available`: `True` when an injected browser provider such as `window.ethereum` exists.
+- `handler.connected`: `True` when the wallet is connected and at least one account is available.
+- `handler.accounts`: List of currently exposed account addresses.
+- `handler.chain_id`: Current chain id as an `int`, or `None`.
+- `handler.chain_id_hex`: Current chain id as a hex string such as `"0x1"`, or `None`.
+- `handler.busy`: `True` while a connect/disconnect action or an interactive wallet request is still pending.
+- `handler.last_error`: Last wallet or bridge error message, if any.
+- `handler.snapshot`: Raw snapshot dictionary returned by the hidden browser component.
+
+### Methods
+
+- `handler.connect()`: Starts the wallet connection flow and reruns the Streamlit script.
+- `handler.disconnect()`: Starts the wallet disconnect flow and reruns the Streamlit script.
+- `handler.request(method, params=None, *, key)`: Sends an EIP-1193 request and returns `(status, result)`.
+- `handler.forget(key)`: Removes a tracked request so the same key can be reused for a new flow.
+- `handler.snapshot_view()`: Returns a typed `WalletSnapshot` dataclass with the main handler fields.
+
+### `request()` status values
+
+`handler.request(...)` returns a `(status, result)` tuple:
+
+- `"pending"`: The wallet request is still waiting for completion in the browser.
+- `"success"`: The request completed successfully and `result` contains the returned value.
+- `"error"`: The request failed and `result` contains an error message.
+
+The `key` argument is required. Requests are tracked by key across reruns, which lets button-triggered flows continue until the browser returns a result.
+
+### Supported request methods
+
+The handler has built-in support for these immediate methods, which resolve from the current snapshot without opening a wallet prompt:
+
+- `eth_accounts`
+- `eth_chainId`
+- `eth_coinbase`
+- `net_version`
+
+The handler also marks these methods as interactive, meaning they can leave `handler.busy == True` while the wallet is waiting for user confirmation:
+
+- `eth_requestAccounts`
+- `eth_sendTransaction`
+- `eth_sign`
+- `eth_signTransaction`
+- `eth_signTypedData`
+- `eth_signTypedData_v1`
+- `eth_signTypedData_v3`
+- `eth_signTypedData_v4`
+- `personal_sign`
+- `wallet_addEthereumChain`
+- `wallet_requestPermissions`
+- `wallet_revokePermissions`
+- `wallet_switchEthereumChain`
+
+Other provider methods can still be passed to `handler.request(...)`. They are tracked as non-interactive requests unless they are in the interactive list above.
+
+## Build
+
+```bash
+python -m build
+```
+
+## Example app
+
+An end-to-end example is included at `examples/streamlit_app.py`.

streamlit_browser_web3-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "streamlit-browser-web3"
+version = "0.1.0"
+description = "Streamlit components and helpers for browser-injected EIP-1193 provider utility."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "streamlit>=1.36"
+]
+keywords = ["streamlit", "web3", "ethereum", "eip-1193", "metamask"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/luismasuelli/streamlit-browser-web3"
+Repository = "https://github.com/luismasuelli/streamlit-browser-web3"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"streamlit_browser_web3" = ["frontend/provider/index.html"]

streamlit_browser_web3-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

streamlit_browser_web3-0.1.0/src/streamlit_browser_web3/__init__.py

@@ -0,0 +1,5 @@
+"""streamlit-web3 package."""
+
+from .provider import WalletHandler, wallet_get
+
+__all__ = ["WalletHandler", "wallet_get"]

streamlit_browser_web3-0.1.0/src/streamlit_browser_web3/frontend/provider/index.html

@@ -0,0 +1,285 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Awesome Crypto Browser Provider</title>
+    <style>
+      html, body {
+        margin: 0;
+        padding: 0;
+        width: 100%;
+        height: 1px;
+        overflow: hidden;
+        background: transparent;
+      }
+
+      #mount {
+        width: 1px;
+        height: 1px;
+        opacity: 0;
+        pointer-events: none;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="mount" aria-hidden="true"></div>
+    <script>
+      const Streamlit = {
+        setComponentReady() {
+          window.parent.postMessage(
+            { isStreamlitMessage: true, type: "streamlit:componentReady", apiVersion: 1 },
+            "*",
+          )
+        },
+        setFrameHeight(height) {
+          window.parent.postMessage(
+            { isStreamlitMessage: true, type: "streamlit:setFrameHeight", height },
+            "*",
+          )
+        },
+        setComponentValue(value) {
+          window.parent.postMessage(
+            { isStreamlitMessage: true, type: "streamlit:setComponentValue", value },
+            "*",
+          )
+        },
+      }
+
+      const state = {
+        snapshot: {
+          providerAvailable: false,
+          connected: false,
+          accounts: [],
+          chainIdHex: null,
+          chainIdDecimal: null,
+        },
+        error: null,
+        lastActionResult: null,
+        requestResults: {},
+        handledActionNonce: null,
+        handledRequestIds: new Set(),
+        activeInteractiveRequestId: null,
+        listenersAttached: false,
+      }
+
+      function publish() {
+        Streamlit.setComponentValue({
+          snapshot: state.snapshot,
+          error: state.error,
+          lastActionResult: state.lastActionResult,
+          requestResults: state.requestResults,
+        })
+      }
+
+      function resize() {
+        Streamlit.setFrameHeight(1)
+      }
+
+      async function syncSnapshot() {
+        state.snapshot.providerAvailable = Boolean(window.ethereum)
+        if (!window.ethereum) {
+          state.snapshot.connected = false
+          state.snapshot.accounts = []
+          state.snapshot.chainIdHex = null
+          state.snapshot.chainIdDecimal = null
+          state.error = "window.ethereum is not available."
+          publish()
+          return
+        }
+
+        try {
+          const [accounts, chainIdHex] = await Promise.all([
+            window.ethereum.request({ method: "eth_accounts" }),
+            window.ethereum.request({ method: "eth_chainId" }),
+          ])
+          state.snapshot.accounts = accounts || []
+          state.snapshot.connected = state.snapshot.accounts.length > 0
+          state.snapshot.chainIdHex = chainIdHex || null
+          state.snapshot.chainIdDecimal = chainIdHex ? parseInt(chainIdHex, 16) : null
+          state.error = null
+        } catch (error) {
+          state.error = error.message || String(error)
+        }
+
+        publish()
+      }
+
+      async function handleAction(action) {
+        if (!action || !action.action || state.handledActionNonce === action.nonce) {
+          return
+        }
+        state.handledActionNonce = action.nonce
+
+        if (!window.ethereum) {
+          state.lastActionResult = {
+            nonce: action.nonce,
+            action: action.action,
+            status: "error",
+            error: "window.ethereum is not available.",
+          }
+          publish()
+          return
+        }
+
+        try {
+          if (action.action === "connect") {
+            const accounts = await window.ethereum.request({ method: "eth_requestAccounts" })
+            state.lastActionResult = {
+              nonce: action.nonce,
+              action: action.action,
+              status: "success",
+              result: accounts || [],
+            }
+          } else if (action.action === "disconnect") {
+            await window.ethereum.request({
+              method: "wallet_revokePermissions",
+              params: [{ eth_accounts: {} }],
+            })
+            state.lastActionResult = {
+              nonce: action.nonce,
+              action: action.action,
+              status: "success",
+              result: true,
+            }
+          } else {
+            state.lastActionResult = {
+              nonce: action.nonce,
+              action: action.action,
+              status: "error",
+              error: `Unsupported action: ${action.action}`,
+            }
+          }
+        } catch (error) {
+          state.lastActionResult = {
+            nonce: action.nonce,
+            action: action.action,
+            status: "error",
+            error: error.message || String(error),
+          }
+          state.error = state.lastActionResult.error
+        }
+
+        await syncSnapshot()
+      }
+
+      async function executeRequest(request) {
+        if (!request || !request.method || state.handledRequestIds.has(request.requestId)) {
+          return
+        }
+        state.handledRequestIds.add(request.requestId)
+
+        if (!window.ethereum) {
+          state.requestResults[String(request.requestId)] = {
+            requestId: request.requestId,
+            method: request.method,
+            status: "error",
+            error: "window.ethereum is not available.",
+          }
+          publish()
+          return
+        }
+
+        try {
+          const result = await window.ethereum.request({
+            method: request.method,
+            params: request.params || [],
+          })
+          state.requestResults[String(request.requestId)] = {
+            requestId: request.requestId,
+            method: request.method,
+            status: "success",
+            result: result,
+          }
+          state.error = null
+        } catch (error) {
+          state.requestResults[String(request.requestId)] = {
+            requestId: request.requestId,
+            method: request.method,
+            status: "error",
+            error: error.message || String(error),
+            code: typeof error.code === "number" ? error.code : -32000,
+          }
+          state.error = state.requestResults[String(request.requestId)].error
+        }
+
+        publish()
+      }
+
+      async function handleRequests(requests) {
+        const requestList = Array.isArray(requests) ? requests : []
+        const readRequests = []
+
+        for (const request of requestList) {
+          if (!request || !request.method || state.handledRequestIds.has(request.requestId)) {
+            continue
+          }
+          if (request.interactive) {
+            if (state.activeInteractiveRequestId !== null) {
+              continue
+            }
+            state.activeInteractiveRequestId = request.requestId
+            try {
+              await executeRequest(request)
+            } finally {
+              state.activeInteractiveRequestId = null
+            }
+          } else {
+            readRequests.push(executeRequest(request))
+          }
+        }
+
+        if (readRequests.length > 0) {
+          await Promise.all(readRequests)
+        }
+      }
+
+      function attachListeners() {
+        if (state.listenersAttached || !window.ethereum) {
+          return
+        }
+
+        state.listenersAttached = true
+
+        window.ethereum.on("accountsChanged", async (accounts) => {
+          state.snapshot.accounts = accounts || []
+          state.snapshot.connected = state.snapshot.accounts.length > 0
+          publish()
+        })
+
+        window.ethereum.on("chainChanged", async (chainIdHex) => {
+          state.snapshot.chainIdHex = chainIdHex || null
+          state.snapshot.chainIdDecimal = chainIdHex ? parseInt(chainIdHex, 16) : null
+          publish()
+        })
+
+        window.ethereum.on("connect", async () => {
+          await syncSnapshot()
+        })
+
+        window.ethereum.on("disconnect", async (error) => {
+          state.error = error && error.message ? error.message : null
+          await syncSnapshot()
+        })
+      }
+
+      window.addEventListener("message", async (event) => {
+        if (!event.data || event.data.type !== "streamlit:render") {
+          return
+        }
+
+        const args = event.data.args || {}
+        attachListeners()
+        await syncSnapshot()
+        await handleAction(args.action || null)
+        await handleRequests(args.requests || [])
+        resize()
+      })
+
+      Streamlit.setComponentReady()
+      attachListeners()
+      resize()
+      syncSnapshot()
+    </script>
+  </body>
+</html>

streamlit_browser_web3-0.1.0/src/streamlit_browser_web3/provider.py

@@ -0,0 +1,382 @@
+from __future__ import annotations
+import json
+import time
+from dataclasses import dataclass
+from importlib.resources import as_file, files
+from typing import Any
+import streamlit as st
+import streamlit.components.v1 as components
+
+
+with as_file(files("streamlit_web3").joinpath("frontend/provider")) as _component_root:
+    _wallet_component = components.declare_component(
+        "streamlit_browser_web3_wallet_component",
+        path=str(_component_root),
+    )
+
+
+INTERACTIVE_METHODS = {
+    "eth_requestAccounts",
+    "eth_sendTransaction",
+    "eth_sign",
+    "eth_signTransaction",
+    "eth_signTypedData",
+    "eth_signTypedData_v1",
+    "eth_signTypedData_v3",
+    "eth_signTypedData_v4",
+    "personal_sign",
+    "wallet_addEthereumChain",
+    "wallet_requestPermissions",
+    "wallet_revokePermissions",
+    "wallet_switchEthereumChain",
+}
+
+
+IMMEDIATE_METHODS = {
+    "eth_accounts",
+    "eth_chainId",
+    "eth_coinbase",
+    "net_version",
+}
+
+
+@dataclass(frozen=True)
+class WalletSnapshot:
+    status: str
+    busy: bool
+    chain_id: int | None
+    chain_id_hex: str | None
+    accounts: list[str]
+    available: bool
+    connected: bool
+    last_error: str | None
+
+
+_STATE_DEFAULTS: dict[str, Any] = {
+    "snapshot": {
+        "providerAvailable": False,
+        "connected": False,
+        "accounts": [],
+        "chainIdHex": None,
+        "chainIdDecimal": None,
+    },
+    "pending_action": None,
+    "action_counter": 0,
+    "request_counter": 0,
+    "requests": {},
+    "last_error": None,
+}
+
+
+def _namespace(key: str) -> str:
+    return f"streamlit_web3:{key}"
+
+
+def _state_get(key: str) -> dict[str, Any]:
+    namespaced = _namespace(key)
+    if namespaced not in st.session_state:
+        st.session_state[namespaced] = {
+            name: value.copy() if isinstance(value, dict) else value
+            for name, value in _STATE_DEFAULTS.items()
+        }
+    return st.session_state[namespaced]
+
+
+def _json_default(value: Any) -> Any:
+    if isinstance(value, bytes):
+        return "0x" + value.hex()
+    raise TypeError(f"Unsupported JSON value: {type(value)!r}")
+
+
+def _fingerprint(method: str, params: Any) -> str:
+    return json.dumps({"method": method, "params": params}, sort_keys=True, default=_json_default)
+
+
+def _is_interactive(method: str) -> bool:
+    return method in INTERACTIVE_METHODS
+
+
+def _pending_requests_payload(state: dict[str, Any]) -> list[dict[str, Any]]:
+    payload: list[dict[str, Any]] = []
+    for slot in state["requests"].values():
+        if slot.get("status") != "pending":
+            continue
+        payload.append(
+            {
+                "requestId": slot["request_id"],
+                "method": slot["method"],
+                "params": slot["params"],
+                "interactive": slot["interactive"],
+            }
+        )
+    return payload
+
+
+class WalletHandler:
+    def __init__(self, *, state: dict[str, Any]) -> None:
+        self._state = state
+
+    def connect(self) -> None:
+        self._state["action_counter"] = int(self._state.get("action_counter", 0)) + 1
+        self._state["pending_action"] = {
+            "action": "connect",
+            "nonce": self._state["action_counter"],
+            "created_at": time.time(),
+        }
+        st.rerun()
+
+    def disconnect(self) -> None:
+        self._state["action_counter"] = int(self._state.get("action_counter", 0)) + 1
+        self._state["pending_action"] = {
+            "action": "disconnect",
+            "nonce": self._state["action_counter"],
+            "created_at": time.time(),
+        }
+        st.rerun()
+
+    @property
+    def available(self) -> bool:
+        """
+        Tells whether the provider is available in the browser
+        or not (i.e. window.ethereum being injected or not).
+        """
+
+        return bool(self.snapshot.get("providerAvailable"))
+
+    @property
+    def connected(self) -> bool:
+        """
+        Tells whether the wallet is connected or not.
+        """
+
+        snapshot = self.snapshot
+        return bool(snapshot.get("connected")) and bool(snapshot.get("accounts"))
+
+    @property
+    def accounts(self) -> list[str]:
+        """
+        Gets the list of available accounts.
+        """
+
+        return list(self.snapshot.get("accounts") or [])
+
+    @property
+    def chain_id(self) -> int | None:
+        """
+        Gets the current chain id.
+        """
+
+        return self.snapshot.get("chainIdDecimal")
+
+    @property
+    def chain_id_hex(self) -> str | None:
+        """
+        Returns the hex. version of the chain id.
+        """
+        return self.snapshot.get("chainIdHex")
+
+    @property
+    def snapshot(self) -> dict[str, Any]:
+        """
+        Gets a snapshot of the current state.
+        """
+
+        return self._state["snapshot"]
+
+    @property
+    def busy(self) -> bool:
+        """
+        Tells whether there is a long-running interactive
+        method being executed at this time. Only one of
+        those methods can run at once.
+        """
+
+        if self._state.get("pending_action"):
+            return True
+        return any(slot.get("status") == "pending" and slot.get("interactive")
+                   for slot in self._state["requests"].values())
+
+    @property
+    def last_error(self) -> str | None:
+        """
+        Gets the last error, if any.
+        """
+
+        return self._state.get("last_error")
+
+    @property
+    def status(self) -> str:
+        """
+        The status means:
+        - not-available: There's no injected provider like window.ethereum.
+        - disconnected: The provider exists, but it is not connected.
+        - connected: The provider is connected and can be used.
+        :return:
+        """
+
+        if not self.available:
+            return "not-available"
+        if not self.connected:
+            return "disconnected"
+        return "connected"
+
+    def snapshot_view(self) -> WalletSnapshot:
+        """
+        Gets a snapshot of the current state, in a structured
+        format.
+        """
+
+        return WalletSnapshot(
+            status=self.status,
+            busy=self.busy,
+            chain_id=self.chain_id,
+            chain_id_hex=self.chain_id_hex,
+            accounts=self.accounts,
+            available=self.available,
+            connected=self.connected,
+            last_error=self.last_error,
+        )
+
+    def forget(self, key: str) -> None:
+        """
+        Pops a particular request.
+        :param key: The request key to forget / stop tracking.
+        """
+
+        self._state["requests"].pop(key, None)
+
+    def request(self, method: str, params: list[Any] | None = None, *, key: str) -> tuple[str, Any]:
+        """
+        Performs a request with the given method and params. Certain
+        methods are deemed interactive. A key is always mandatory so
+        the request can be tracked.
+
+        Certain methods are interactive and will mark this provider
+        as .busy. Make sure you don't invoke two concurrent methods
+        like this, and always account for the .busy flag somewhere
+        before invoking these methods.
+        :param method: The RPC method name.
+        :param params: The RPC method params.
+        :param key: The key of this request.
+        :return: The result of the request (status, content), where
+            status is "success", "error" or "pending" and the content
+            can be any valid content for the "error" status (a detail
+            on the failure) or "success" (e.g. the tx. receipt hash).
+        """
+
+        params = params or []
+
+        if method in IMMEDIATE_METHODS:
+            return "success", self._immediate_result(method)
+
+        if not self.available:
+            return "error", "window.ethereum is not available"
+
+        interactive = _is_interactive(method)
+        slot = self._state["requests"].get(key)
+        fingerprint = _fingerprint(method, params)
+
+        if slot and slot["fingerprint"] != fingerprint:
+            if slot["status"] == "pending":
+                return "error", f"Request key `{key}` already has a different pending request."
+            self.forget(key)
+            slot = None
+
+        if interactive and self.busy and not (slot and slot["status"] == "pending" and slot["interactive"]):
+            return "error", "Another interactive wallet request is already pending."
+
+        if slot:
+            if slot["status"] == "pending":
+                return "pending", None
+            if slot["status"] == "success":
+                return "success", slot.get("result")
+            return "error", slot.get("error")
+
+        request_id = self._next_counter("request_counter")
+        self._state["requests"][key] = {
+            "request_id": request_id,
+            "key": key,
+            "method": method,
+            "params": params,
+            "fingerprint": fingerprint,
+            "interactive": interactive,
+            "status": "pending",
+            "result": None,
+            "error": None,
+            "created_at": time.time(),
+        }
+        st.rerun()
+
+    def _immediate_result(self, method: str) -> Any:
+        if method == "eth_accounts":
+            return self.accounts
+        if method == "eth_chainId":
+            return self.chain_id_hex
+        if method == "eth_coinbase":
+            return self.accounts[0] if self.accounts else None
+        if method == "net_version":
+            return str(self.chain_id) if self.chain_id is not None else None
+        raise ValueError(f"Unsupported immediate method: {method}")
+
+    def _next_counter(self, counter_name: str) -> int:
+        self._state[counter_name] = int(self._state.get(counter_name, 0)) + 1
+        return self._state[counter_name]
+
+
+def _sync_component_value(state: dict[str, Any], component_value: dict[str, Any]) -> None:
+    if not isinstance(component_value, dict):
+        return
+
+    snapshot = component_value.get("snapshot")
+    if isinstance(snapshot, dict):
+        state["snapshot"] = snapshot
+
+    error = component_value.get("error")
+    if error:
+        state["last_error"] = error
+
+    action_result = component_value.get("lastActionResult") or {}
+    pending_action = state.get("pending_action")
+    if pending_action and action_result.get("nonce") == pending_action.get("nonce"):
+        state["pending_action"] = None
+        if action_result.get("error"):
+            state["last_error"] = action_result["error"]
+
+    request_results = component_value.get("requestResults") or {}
+    requests_by_id = {slot["request_id"]: slot for slot in state["requests"].values()}
+    for raw_request_id, result in request_results.items():
+        try:
+            request_id = int(raw_request_id)
+        except (TypeError, ValueError):
+            continue
+        slot = requests_by_id.get(request_id)
+        if not slot or slot["status"] != "pending":
+            continue
+        if result.get("status") == "success":
+            slot["status"] = "success"
+            slot["result"] = result.get("result")
+            slot["error"] = None
+        else:
+            slot["status"] = "error"
+            slot["error"] = result.get("error") or "Wallet request failed."
+            slot["result"] = None
+            state["last_error"] = slot["error"]
+
+
+def wallet_get() -> WalletHandler:
+    """
+    Gets a wallet handler. Meant to be used as a singleton call.
+    :return:
+    """
+
+    key = "__handler__"
+    state = _state_get(key)
+    component_value = _wallet_component(
+        key=f"streamlit_web3_wallet_component:{key}",
+        default={},
+        action=state.get("pending_action"),
+        requests=_pending_requests_payload(state),
+        hidden=True,
+    )
+    _sync_component_value(state, component_value if isinstance(component_value, dict) else {})
+    return WalletHandler(state=state)

streamlit_browser_web3-0.1.0/src/streamlit_browser_web3.egg-info/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: streamlit-browser-web3
+Version: 0.1.0
+Summary: Streamlit components and helpers for browser-injected EIP-1193 provider utility.
+Project-URL: Homepage, https://github.com/luismasuelli/streamlit-browser-web3
+Project-URL: Repository, https://github.com/luismasuelli/streamlit-browser-web3
+Keywords: streamlit,web3,ethereum,eip-1193,metamask
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: streamlit>=1.36
+Dynamic: license-file
+
+# streamlit-web3
+
+`streamlit-web3` packages a hidden Streamlit component that bridges a browser-injected EIP-1193 wallet provider into
+Web3.py.
+
+## Install
+
+```bash
+pip install streamlit-web3
+```
+
+## Minimal usage
+
+```python
+import streamlit as st
+
+from streamlit_browser_web3 import wallet_get
+
+handler = wallet_get()
+if handler.status == "connected":
+    if st.button("Disconnect your wallet"):
+        handler.disconnect()
+    page_body(handler)
+else:
+    if st.button("Connect your wallet"):
+        handler.connect()
+```
+
+## Important Streamlit behavior
+
+Wallet operations are asynchronous in the browser but Streamlit scripts are synchronous and rerun-driven.
+
+- `wallet_get()` must be rendered on every rerun.
+- A wallet request may complete over multiple reruns.
+- For button-triggered Web3 calls, persist the user intent in `st.session_state` until the call returns.
+- Requests are serialized through the hidden browser bridge.
+
+Chain metadata and ERC-20 helper code are intentionally kept in the example app, not in the package.
+
+## Handler API
+
+`wallet_get()` returns a `WalletHandler` instance. Render it on every rerun and use the same handler object as your app's wallet state interface.
+
+### State properties
+
+- `handler.status`: One of `"not-available"`, `"disconnected"`, or `"connected"`.
+- `handler.available`: `True` when an injected browser provider such as `window.ethereum` exists.
+- `handler.connected`: `True` when the wallet is connected and at least one account is available.
+- `handler.accounts`: List of currently exposed account addresses.
+- `handler.chain_id`: Current chain id as an `int`, or `None`.
+- `handler.chain_id_hex`: Current chain id as a hex string such as `"0x1"`, or `None`.
+- `handler.busy`: `True` while a connect/disconnect action or an interactive wallet request is still pending.
+- `handler.last_error`: Last wallet or bridge error message, if any.
+- `handler.snapshot`: Raw snapshot dictionary returned by the hidden browser component.
+
+### Methods
+
+- `handler.connect()`: Starts the wallet connection flow and reruns the Streamlit script.
+- `handler.disconnect()`: Starts the wallet disconnect flow and reruns the Streamlit script.
+- `handler.request(method, params=None, *, key)`: Sends an EIP-1193 request and returns `(status, result)`.
+- `handler.forget(key)`: Removes a tracked request so the same key can be reused for a new flow.
+- `handler.snapshot_view()`: Returns a typed `WalletSnapshot` dataclass with the main handler fields.
+
+### `request()` status values
+
+`handler.request(...)` returns a `(status, result)` tuple:
+
+- `"pending"`: The wallet request is still waiting for completion in the browser.
+- `"success"`: The request completed successfully and `result` contains the returned value.
+- `"error"`: The request failed and `result` contains an error message.
+
+The `key` argument is required. Requests are tracked by key across reruns, which lets button-triggered flows continue until the browser returns a result.
+
+### Supported request methods
+
+The handler has built-in support for these immediate methods, which resolve from the current snapshot without opening a wallet prompt:
+
+- `eth_accounts`
+- `eth_chainId`
+- `eth_coinbase`
+- `net_version`
+
+The handler also marks these methods as interactive, meaning they can leave `handler.busy == True` while the wallet is waiting for user confirmation:
+
+- `eth_requestAccounts`
+- `eth_sendTransaction`
+- `eth_sign`
+- `eth_signTransaction`
+- `eth_signTypedData`
+- `eth_signTypedData_v1`
+- `eth_signTypedData_v3`
+- `eth_signTypedData_v4`
+- `personal_sign`
+- `wallet_addEthereumChain`
+- `wallet_requestPermissions`
+- `wallet_revokePermissions`
+- `wallet_switchEthereumChain`
+
+Other provider methods can still be passed to `handler.request(...)`. They are tracked as non-interactive requests unless they are in the interactive list above.
+
+## Build
+
+```bash
+python -m build
+```
+
+## Example app
+
+An end-to-end example is included at `examples/streamlit_app.py`.

streamlit_browser_web3-0.1.0/src/streamlit_browser_web3.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/streamlit_browser_web3/__init__.py
+src/streamlit_browser_web3/provider.py
+src/streamlit_browser_web3.egg-info/PKG-INFO
+src/streamlit_browser_web3.egg-info/SOURCES.txt
+src/streamlit_browser_web3.egg-info/dependency_links.txt
+src/streamlit_browser_web3.egg-info/requires.txt
+src/streamlit_browser_web3.egg-info/top_level.txt
+src/streamlit_browser_web3/frontend/provider/index.html

streamlit_browser_web3-0.1.0/src/streamlit_browser_web3.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

streamlit_browser_web3-0.1.0/src/streamlit_browser_web3.egg-info/requires.txt

@@ -0,0 +1 @@
+streamlit>=1.36

streamlit_browser_web3-0.1.0/src/streamlit_browser_web3.egg-info/top_level.txt

@@ -0,0 +1 @@
+streamlit_browser_web3