toll-sdk 0.1.0__py3-none-any.whl

toll_sdk/__init__.py

@@ -0,0 +1,397 @@
+"""toll-sdk (import toll_sdk): client for Toll's remote MCP server (https://t0ll.xyz/mcp).
+
+Information only, not financial advice.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import re
+import socket
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
+
+__all__ = [
+    "PaymentRequirements",
+    "SignPayment",
+    "Toll",
+    "TollError",
+    "TollResult",
+    "is_valid_address",
+    "is_valid_wallet",
+    "parse_paid_url",
+    "parse_pending",
+    "read_requirements",
+]
+
+_EVM = re.compile(r"0x[0-9a-fA-F]{40}")
+_BASE58 = re.compile(r"[1-9A-HJ-NP-Za-km-z]{32,44}")
+# Only the upsell line counts: a finished LARP answer also lists Toll's own x402 endpoint as a "working part".
+_PAID_URL = re.compile(r"paid (?:LARP )?check of this coin \(x402\):\s*(https://t0ll\.xyz/api/x402/[^\s)\"'<>]+)", re.I)
+_AGAIN = re.compile(r"again in (?:about )?(\d+)\s*(?:s\b|sec)", re.I)
+_PAID_PREFIX = "https://t0ll.xyz/api/x402/"
+_TIMEOUTS = (TimeoutError, socket.timeout)
+_SETTLE_NOTE = (
+    " The payment may have settled: do not retry this call with a new signature;"
+    " resend the same payment header to get the answer."
+)
+
+
+class TollError(Exception):
+    """Any failure: HTTP, JSON-RPC, timeout, server-side input error, bad input."""
+
+    def __init__(
+        self,
+        message: str,
+        status: Optional[int] = None,
+        code: Optional[int] = None,
+        retry_after_s: Optional[int] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.retry_after_s = retry_after_s
+
+
+@dataclass
+class TollResult:
+    text: str
+    paid_url: Optional[str]
+    pending: Optional[Dict[str, int]]  # {"retry_after_s": n}: part of the answer is still being read, ask again then
+
+
+@dataclass
+class PaymentRequirements:
+    """What a paid URL asks for, read from its 402 answer."""
+
+    x402_version: int
+    """2 when the 402 carried a PAYMENT-REQUIRED header (sent back as PAYMENT-SIGNATURE), else 1 (X-PAYMENT)."""
+    payment_required: Dict[str, Any]
+    """The decoded 402 object: base64 JSON of the PAYMENT-REQUIRED header (v2) or the JSON body (v1)."""
+    accepts: List[Dict[str, Any]]
+    """payment_required["accepts"]: scheme, network, asset, amount (v2) or maxAmountRequired (v1), payTo, ..."""
+
+
+SignPayment = Callable[[PaymentRequirements, str], str]
+"""sign(requirements, url) -> the payment header value. pay() calls it at most once per call."""
+
+
+def _clamp_seconds(value: Any, fallback: int) -> int:
+    """Seconds to wait, never below 1 (a 0 or junk value must not become a tight loop)."""
+    try:
+        n = float(value)
+    except (TypeError, ValueError):
+        return fallback
+    if n != n or n in (float("inf"), float("-inf")):
+        return fallback
+    return max(1, int(-(-n // 1)))
+
+
+def is_valid_address(value: object) -> bool:
+    """Token address: 0x + 40 hex, or a Solana base58 mint (32-44 chars)."""
+    return isinstance(value, str) and bool(_EVM.fullmatch(value) or _BASE58.fullmatch(value))
+
+
+def is_valid_wallet(value: object) -> bool:
+    """Wallet address: 0x + 40 hex."""
+    return isinstance(value, str) and bool(_EVM.fullmatch(value))
+
+
+def parse_paid_url(text: str) -> Optional[str]:
+    m = _PAID_URL.search(text)
+    return m.group(1).rstrip(".,;:") if m else None
+
+
+def parse_pending(text: str) -> Optional[Dict[str, int]]:
+    m = _AGAIN.search(text)
+    return {"retry_after_s": _clamp_seconds(m.group(1), 5)} if m else None
+
+
+def _check_address(value: object, what: str = "address") -> None:
+    if not is_valid_address(value):
+        raise TollError(f"Invalid {what}: expected 0x + 40 hex characters or a Solana base58 mint (32-44 characters).")
+
+
+def _check_wallet(value: object) -> None:
+    if not is_valid_wallet(value):
+        raise TollError("Invalid wallet: expected 0x + 40 hex characters.")
+
+
+def _check_chain(chain: Optional[str], allowed: tuple) -> None:
+    if chain is not None and chain not in allowed:
+        raise TollError(f'Invalid chain "{chain}": use {", ".join(allowed)}.')
+
+
+def _parse_body(raw: str) -> Any:
+    t = raw.strip()
+    if t.startswith("{"):
+        return json.loads(t)
+    for line in t.splitlines():
+        if line.startswith("data:"):
+            return json.loads(line[5:].strip())
+    raise ValueError("no data")
+
+
+class Toll:
+    """Client. `opener` is a urllib OpenerDirector (or anything with .open(request, timeout=...))."""
+
+    def __init__(
+        self,
+        base_url: str = "https://t0ll.xyz",
+        opener: Any = None,
+        timeout: float = 30.0,
+        sleep: Callable[[float], None] = time.sleep,
+        sign: Optional[SignPayment] = None,
+        pay_timeout: float = 300.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self._opener = opener or urllib.request.build_opener()
+        self.timeout = timeout
+        self.pay_timeout = pay_timeout
+        self._sign = sign
+        self._sleep = sleep
+        self._next_id = 1
+
+    # -- transport ---------------------------------------------------------
+    def _http(self, req: urllib.request.Request, timeout: float, note: str = "") -> tuple:
+        """One request, body read inside the timeout. Returns (status, headers, text); HTTP errors are returned too."""
+        try:
+            with self._opener.open(req, timeout=timeout) as res:
+                raw = res.read().decode("utf-8", "replace")
+                return int(getattr(res, "status", 200) or 200), getattr(res, "headers", None) or {}, raw
+        except urllib.error.HTTPError as e:
+            try:
+                raw = e.read().decode("utf-8", "replace") if hasattr(e, "read") else ""
+            except Exception:
+                raw = ""
+            return int(e.code), e.headers or {}, raw
+        except _TIMEOUTS:
+            raise TollError(f"Request to {req.full_url} timed out after {timeout:g} s.{note}") from None
+        except urllib.error.URLError as e:
+            if isinstance(e.reason, _TIMEOUTS):
+                raise TollError(f"Request to {req.full_url} timed out after {timeout:g} s.{note}") from None
+            raise TollError(f"Request to {req.full_url} failed: {e}.{note}") from None
+        except OSError as e:
+            raise TollError(f"Request to {req.full_url} failed: {e}.{note}") from None
+
+    def _rpc(self, method: str, params: Dict[str, Any]) -> Any:
+        payload = json.dumps({"jsonrpc": "2.0", "id": self._next_id, "method": method, "params": params}).encode()
+        self._next_id += 1
+        req = urllib.request.Request(
+            f"{self.base_url}/mcp",
+            data=payload,
+            method="POST",
+            headers={"content-type": "application/json", "accept": "application/json, text/event-stream"},
+        )
+        status, _headers, raw = self._http(req, self.timeout)
+        if not 200 <= status < 300:
+            raise TollError(f"Toll answered HTTP {status}" + (f": {raw[:200]}" if raw else ""), status=status)
+        try:
+            body = _parse_body(raw)
+        except ValueError:
+            raise TollError("Toll sent an answer that is not JSON-RPC.") from None
+        if isinstance(body, dict) and body.get("error"):
+            err = body["error"]
+            raise TollError(f"Toll JSON-RPC error {err.get('code')}: {err.get('message')}", code=err.get("code"))
+        return body.get("result") if isinstance(body, dict) else None
+
+    # -- tools -------------------------------------------------------------
+    def tools(self) -> List[Dict[str, Any]]:
+        r = self._rpc("tools/list", {})
+        return (r or {}).get("tools", [])
+
+    def call(self, name: str, args: Optional[Dict[str, Any]] = None) -> TollResult:
+        """Call any tool by its server name. isError answers raise TollError."""
+        r = self._rpc("tools/call", {"name": name, "arguments": args or {}}) or {}
+        content = r.get("content")
+        text = "\n".join(str(c.get("text", "")) for c in content if isinstance(c, dict) and c.get("type") == "text") if isinstance(content, list) else ""
+        if r.get("isError"):
+            p = parse_pending(text)
+            raise TollError(text.split("\n\n")[0] or "Toll reported an error.", retry_after_s=p["retry_after_s"] if p else None)
+        pending = parse_pending(text) if re.search(r"still reading", text, re.I) else None
+        return TollResult(text=text, paid_url=parse_paid_url(text), pending=pending)
+
+    def check_coin(self, address: str, chain: Optional[str] = None) -> TollResult:
+        _check_address(address)
+        _check_chain(chain, ("rh", "sol", "bsc"))
+        return self.call("check_coin", {"address": address, **({"chain": chain} if chain else {})})
+
+    def larp_check(self, token: str, chain: Optional[str] = None, wait: bool = False) -> TollResult:
+        """LARP check.
+
+        wait=True asks again while part of the answer is still being read, or while Toll answers that it is
+        busy with many new LARP checks (a TollError with retry_after_s): max 3 tries, max 120 s waiting.
+        """
+        _check_address(token, "token")
+        _check_chain(chain, ("rh", "sol"))
+        args = {"token": token, **({"chain": chain} if chain else {})}
+        if not wait:
+            return self.call("larp_check", args)
+        waited = 0
+        tries = 0
+        while True:
+            tries += 1
+            res: Optional[TollResult] = None
+            busy: Optional[TollError] = None
+            try:
+                res = self.call("larp_check", args)
+            except TollError as e:
+                if e.retry_after_s is None:
+                    raise
+                busy = e
+            if res is not None:
+                if not res.pending:
+                    return res
+                s = res.pending["retry_after_s"]
+            else:
+                assert busy is not None and busy.retry_after_s is not None
+                s = busy.retry_after_s
+            if tries >= 3 or waited + s > 120:
+                if busy is not None:
+                    raise busy
+                assert res is not None
+                return res
+            self._sleep(s)
+            waited += s
+
+    def dev_record(self, wallet: str, chain: Optional[str] = None) -> TollResult:
+        _check_wallet(wallet)
+        _check_chain(chain, ("rh", "bsc"))
+        return self.call("dev_record", {"wallet": wallet, **({"chain": chain} if chain else {})})
+
+    def launch_record(self, address: str) -> TollResult:
+        _check_wallet(address)
+        return self.call("launch_record", {"address": address})
+
+    def wallet_privacy(self, wallet: str) -> TollResult:
+        _check_wallet(wallet)
+        return self.call("wallet_privacy", {"wallet": wallet})
+
+    def fresh_launches(self, limit: Optional[int] = None) -> TollResult:
+        if limit is not None and (isinstance(limit, bool) or not isinstance(limit, int) or not 1 <= limit <= 20):
+            raise TollError("Invalid limit: use a whole number from 1 to 20.")
+        return self.call("fresh_launches", {} if limit is None else {"limit": limit})
+
+    def chain_pulse(self) -> TollResult:
+        return self.call("chain_pulse", {})
+
+    # -- paying ------------------------------------------------------------
+    def pay(self, paid_url: str, sign: Optional[SignPayment] = None, timeout: Optional[float] = None) -> Any:
+        """Pay a paid x402 URL (the paid_url of a result) and return its JSON.
+
+        1. GET without payment: 402 with the requirements (v2 PAYMENT-REQUIRED header, else the v1 body).
+        2. Call sign(requirements, url) ONCE for the payment header value.
+        3. GET with it (v2: PAYMENT-SIGNATURE, v1: X-PAYMENT). On 402 {"pending": true} resend EXACTLY the
+           same header after Retry-After (at least 1 s), max 5 tries and 300 s of waiting. 200 JSON is the
+           answer; any other 402 after paying raises TollError "payment not accepted". It never signs twice.
+        The whole call is bounded by `timeout` (default pay_timeout, 300 s).
+        """
+        if not isinstance(paid_url, str) or not paid_url.startswith(_PAID_PREFIX):
+            raise TollError("pay() only takes https://t0ll.xyz/api/x402/... URLs.")
+        signer = sign or self._sign
+        if signer is None:
+            raise TollError("pay() needs a sign function: Toll(sign=...) or pay(url, sign=...). See the README (paying).")
+        total = self.pay_timeout if timeout is None else timeout
+        deadline = time.monotonic() + total
+
+        def left() -> float:
+            return max(0.001, deadline - time.monotonic())
+
+        def get(headers: Dict[str, str], note: str = "") -> tuple:
+            req = urllib.request.Request(paid_url, method="GET", headers={"accept": "application/json", **headers})
+            return self._http(req, left(), note)
+
+        # 1. Unpaid GET: read what to pay.
+        status, headers, raw = get({})
+        if 200 <= status < 300:
+            return _json_answer(raw, status)
+        if status != 402:
+            raise _http_error(status, raw)
+        requirements = read_requirements(headers, raw)
+
+        # 2. One signature for this call.
+        try:
+            header = signer(requirements, paid_url)
+        except Exception as e:
+            raise TollError(f"sign() failed, nothing was sent: {e}") from None
+        if not isinstance(header, str) or not header.strip() or "\r" in header or "\n" in header:
+            raise TollError("sign() must return the payment header value as one non-empty line; nothing was sent.")
+        name = "PAYMENT-SIGNATURE" if requirements.x402_version == 2 else "X-PAYMENT"
+
+        # 3. Paid GET, resending the same header while the answer is pending.
+        waited = 0
+        tries = 0
+        while True:
+            tries += 1
+            if time.monotonic() >= deadline:
+                raise TollError(f"pay() timed out after {total:g} s.{_SETTLE_NOTE}")
+            status, headers, raw = get({name: header}, _SETTLE_NOTE)
+            data = _try_json(raw)
+            if status == 402 and isinstance(data, dict) and data.get("pending") is True:
+                s = _clamp_seconds(_header(headers, "retry-after"), 5)
+                if tries >= 5 or waited + s > 300 or time.monotonic() + s > deadline:
+                    raise TollError(
+                        f"The paid answer is still being read after {tries} tries (nothing is charged while it is pending)."
+                        " Resend the same payment header later; do not sign a new one for this call.",
+                        status=402,
+                        retry_after_s=s,
+                    )
+                self._sleep(s)
+                waited += s
+                continue
+            if status == 402:
+                why = f" ({data['error']})" if isinstance(data, dict) and isinstance(data.get("error"), str) else ""
+                raise TollError(f"payment not accepted: Toll answered 402 to the signed payment{why}. pay() does not sign again.", status=402)
+            if not 200 <= status < 300:
+                raise _http_error(status, raw, _SETTLE_NOTE)
+            return _json_answer(raw, status)
+
+
+def read_requirements(headers: Any, raw: str) -> PaymentRequirements:
+    """Read a 402: v2 from the PAYMENT-REQUIRED header when it decodes, else v1 from the JSON body."""
+    h = _header(headers, "payment-required")
+    if h:
+        try:
+            pr = json.loads(base64.b64decode(h.strip()).decode("utf-8"))
+            if isinstance(pr, dict) and isinstance(pr.get("accepts"), list) and pr["accepts"]:
+                return PaymentRequirements(x402_version=2, payment_required=pr, accepts=pr["accepts"])
+        except (ValueError, UnicodeDecodeError):
+            pass
+    body = _try_json(raw)
+    if isinstance(body, dict) and isinstance(body.get("accepts"), list) and body["accepts"]:
+        return PaymentRequirements(x402_version=1, payment_required=body, accepts=body["accepts"])
+    raise TollError("Toll answered 402 without x402 payment requirements; nothing was signed.", status=402)
+
+
+def _try_json(raw: str) -> Any:
+    try:
+        return json.loads(raw) if raw else None
+    except ValueError:
+        return None
+
+
+def _json_answer(raw: str, status: int) -> Any:
+    data = _try_json(raw)
+    if data is None:
+        raise TollError("The paid answer was not JSON.", status=status)
+    return data
+
+
+def _http_error(status: int, raw: str, note: str = "") -> TollError:
+    return TollError(f"Toll answered HTTP {status}" + (f": {raw[:200]}" if raw else "") + "." + note, status=status)
+
+
+def _header(headers: Any, name: str) -> Optional[str]:
+    if not headers:
+        return None
+    get = getattr(headers, "get", None)
+    if get is not None and hasattr(headers, "get_all"):  # http.client.HTTPMessage: case-insensitive
+        v = get(name)
+        return None if v is None else str(v)
+    for k in headers:
+        if str(k).lower() == name:
+            return str(headers[k])
+    return None

toll_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.5
+Name: toll-sdk
+Version: 0.1.0
+Summary: Client for Toll's coin checks (Robinhood Chain, Solana, BSC) over MCP. Standard library only.
+Project-URL: Homepage, https://t0ll.xyz/agents
+Project-URL: Documentation, https://t0ll.xyz/llms.txt
+Project-URL: Repository, https://github.com/t0ll-xyz/toll-plugins
+Author: Toll
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agent,bsc,larp,mcp,robinhood-chain,rug-check,solana,toll,x402
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# toll-sdk
+
+Python client for [Toll](https://t0ll.xyz/agents)'s coin checks, read from the chain (Robinhood Chain, Solana, BSC), over Toll's remote MCP server. Who is behind a coin, the dev's record, and whether there is a real product behind it. Standard library only, Python >= 3.9, typed.
+
+Information only, not financial advice.
+
+## Install
+
+```sh
+pip install toll-sdk        # import name: toll_sdk
+```
+
+## Example
+
+```python
+from toll_sdk import Toll
+
+toll = Toll()
+check = toll.check_coin("0xff9e86e6b21fd688027981bee4b64c8b6b804ed3", chain="rh")
+print(check.text)                      # markdown facts from the chain
+larp = toll.larp_check("0xff9e86e6b21fd688027981bee4b64c8b6b804ed3", wait=True)
+print(larp.text)                       # product found / partly found / not found / not read
+```
+
+Every method returns `TollResult(text, paid_url, pending)`. `pending` (`{"retry_after_s": n}` or None) means part of the answer is still being read: ask again after that many seconds. `paid_url` is set when the free coins are used up (see below).
+
+## API
+
+`Toll(base_url="https://t0ll.xyz", opener=None, timeout=30.0, sign=None, pay_timeout=300.0)`
+
+- `check_coin(address, chain=None)` - chain is `rh`, `sol` or `bsc`
+- `larp_check(token, chain=None, wait=False)` - `rh` or `sol`; `wait=True` asks again after the seconds the server gives while part of the answer is still being read or Toll is busy with many new LARP checks (max 3 tries, max 120 s)
+- `dev_record(wallet, chain=None)`, `launch_record(address)`, `wallet_privacy(wallet)`, `fresh_launches(limit=None)`, `chain_pulse()`
+- `tools()` lists the server's tools, `call(name, args)` calls any of them
+- `pay(paid_url, sign=None, timeout=None)` - pays a paid URL once and returns its JSON (see below)
+- `is_valid_address(x)`, `is_valid_wallet(x)` - the checks run before anything is sent
+- Failures (HTTP, JSON-RPC, timeouts, server-side input errors) raise `TollError`.
+
+## Free limit and the paid path
+
+10 new coins a day per caller are free (coins already read stay free). Past that, the result carries `paid_url`, the x402 endpoint for that coin (0.05 USDG on Robinhood Chain, charged only for a whole answer).
+
+`pay(paid_url)` runs the x402 flow itself and asks your `sign` function for one payment:
+
+1. GET the URL without payment. Toll answers 402 with what to pay: x402 v2 in the `PAYMENT-REQUIRED` header, v1 in the body.
+2. Call `sign(requirements, url)` **once**. It returns the payment header value.
+3. GET again with it (`PAYMENT-SIGNATURE` for v2, `X-PAYMENT` for v1, following what the 402 offered). While Toll is still reading the coin it answers 402 `{"pending": true}` (nothing charged): `pay` resends **exactly the same header** after `Retry-After` (at least 1 s), up to 5 tries and 300 s. A 200 is the answer. Any other 402 after paying raises `TollError` "payment not accepted"; `pay` never signs a second payment for one call.
+
+The whole call has its own timeout (`pay_timeout`, default 300 s). If it times out or the connection drops after the payment was sent, the error says the payment may have settled: do not retry that call with a new signature; resend the same header.
+
+### The `sign` contract
+
+```python
+from toll_sdk import PaymentRequirements, Toll
+
+def sign(req: PaymentRequirements, url: str) -> str:
+    # req.x402_version: 2 when the 402 had a PAYMENT-REQUIRED header, else 1
+    # req.payment_required: the decoded 402 object; req.accepts: scheme, network "eip155:4663",
+    #   asset (USDG), amount (v2) / maxAmountRequired (v1), payTo, maxTimeoutSeconds, extra
+    # Check the amount and payTo, sign an EIP-3009 USDG transfer authorization with your x402 client,
+    # and return the header value for req.x402_version (the base64 payment payload).
+    ...
+
+toll = Toll(sign=sign)
+r = toll.check_coin(address)
+if r.paid_url:
+    print(toll.pay(r.paid_url))
+```
+
+Your key never touches this SDK. Without a `sign`, `pay` raises before any request. The JavaScript SDK's README has a worked `sign` built on `@priors/x402`. Docs: <https://t0ll.xyz/agents>, <https://t0ll.xyz/llms.txt>, <https://t0ll.xyz/agents/x402>.
+
+MIT.

toll_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+toll_sdk/__init__.py,sha256=mLa8Z2PiGUKB-8PZbxUKzQa5RUdCUiTXz_VewIfkM3c,16988
+toll_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+toll_sdk-0.1.0.dist-info/METADATA,sha256=sBrCUNWdd3aapku54_k8QG9TQv4YapAFTbOvNsj0evA,5104
+toll_sdk-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+toll_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=fYxg0YwHSQpc90DS9iZXfliQn-nejEdtdHu9448-mnc,1061
+toll_sdk-0.1.0.dist-info/RECORD,,

toll_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

toll_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Toll
+
+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.