barter-sdk 1.0.0__tar.gz

barter_sdk-1.0.0/LICENSE

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

barter_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: barter-sdk
+Version: 1.0.0
+Summary: Proof of Trade Protocol — Python SDK for BTR-Trust soulbound reputation
+Author: TheBarmaEffect
+License: MIT
+Keywords: barter,bitcoin,lightning,trust,reputation,web3
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: web3>=6.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Dynamic: license-file
+
+# barter-sdk
+
+Python SDK for the BTR Proof of Trade Protocol.
+
+## Install
+
+```bash
+pip install barter-sdk
+```
+
+## Usage
+
+```python
+import btr
+
+client = btr.BarterClient(network="sepolia")
+
+# Get trust score
+score = client.trust.get_score("0x742d...3F9a")
+
+# Get full profile
+profile = client.trust.get_profile("0x742d...3F9a")
+print(f"Score: {profile.score}")
+print(f"Trades: {profile.trade_count}")
+
+# Compliance check
+report = client.compliance.full_report("0x742d...3F9a")
+print(f"Risk: {report.risk_level}")
+```
+
+## License
+
+MIT

barter_sdk-1.0.0/README.md

@@ -0,0 +1,33 @@
+# barter-sdk
+
+Python SDK for the BTR Proof of Trade Protocol.
+
+## Install
+
+```bash
+pip install barter-sdk
+```
+
+## Usage
+
+```python
+import btr
+
+client = btr.BarterClient(network="sepolia")
+
+# Get trust score
+score = client.trust.get_score("0x742d...3F9a")
+
+# Get full profile
+profile = client.trust.get_profile("0x742d...3F9a")
+print(f"Score: {profile.score}")
+print(f"Trades: {profile.trade_count}")
+
+# Compliance check
+report = client.compliance.full_report("0x742d...3F9a")
+print(f"Risk: {report.risk_level}")
+```
+
+## License
+
+MIT

barter_sdk-1.0.0/barter_sdk.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: barter-sdk
+Version: 1.0.0
+Summary: Proof of Trade Protocol — Python SDK for BTR-Trust soulbound reputation
+Author: TheBarmaEffect
+License: MIT
+Keywords: barter,bitcoin,lightning,trust,reputation,web3
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: web3>=6.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Dynamic: license-file
+
+# barter-sdk
+
+Python SDK for the BTR Proof of Trade Protocol.
+
+## Install
+
+```bash
+pip install barter-sdk
+```
+
+## Usage
+
+```python
+import btr
+
+client = btr.BarterClient(network="sepolia")
+
+# Get trust score
+score = client.trust.get_score("0x742d...3F9a")
+
+# Get full profile
+profile = client.trust.get_profile("0x742d...3F9a")
+print(f"Score: {profile.score}")
+print(f"Trades: {profile.trade_count}")
+
+# Compliance check
+report = client.compliance.full_report("0x742d...3F9a")
+print(f"Risk: {report.risk_level}")
+```
+
+## License
+
+MIT

barter_sdk-1.0.0/barter_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+barter_sdk.egg-info/PKG-INFO
+barter_sdk.egg-info/SOURCES.txt
+barter_sdk.egg-info/dependency_links.txt
+barter_sdk.egg-info/requires.txt
+barter_sdk.egg-info/top_level.txt
+btr/__init__.py
+btr/client.py
+btr/compliance.py
+btr/constants.py
+btr/credit.py
+btr/exceptions.py
+btr/trade.py
+btr/trust.py
+btr/types.py
+tests/test_compliance.py
+tests/test_integration.py
+tests/test_trade.py
+tests/test_trust.py

barter_sdk-1.0.0/barter_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

barter_sdk-1.0.0/barter_sdk.egg-info/requires.txt

@@ -0,0 +1,8 @@
+web3>=6.0.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+
+[dev]
+pytest>=7.0
+pytest-cov
+pytest-asyncio

barter_sdk-1.0.0/barter_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+btr

barter_sdk-1.0.0/btr/__init__.py

@@ -0,0 +1,19 @@
+"""BTR — Proof of Trade Protocol SDK"""
+from btr.client import BarterClient
+from btr.types import (
+    TrustProfile, Trade, TradeStatus, ComplianceReport,
+    AnomalyFlag, VelocityReport, ClusterReport, ScoreEvent
+)
+from btr.exceptions import (
+    BarterError, InvalidAddressError, TradeNotFoundError,
+    PreimageMismatchError, InsufficientAmountError, SelfTradeError
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "BarterClient", "TrustProfile", "Trade", "TradeStatus",
+    "ComplianceReport", "AnomalyFlag", "VelocityReport",
+    "ClusterReport", "ScoreEvent", "BarterError",
+    "InvalidAddressError", "TradeNotFoundError",
+    "PreimageMismatchError", "InsufficientAmountError", "SelfTradeError",
+]

barter_sdk-1.0.0/btr/client.py

@@ -0,0 +1,68 @@
+import os
+from typing import Optional
+from web3 import Web3
+from btr.trust import TrustClient
+from btr.trade import TradeClient
+from btr.credit import CreditClient
+from btr.compliance import ComplianceClient
+from btr.constants import CONTRACTS, ABIS, DEFAULT_RPC
+
+class BarterClient:
+    """Main client for the BTR Proof of Trade Protocol.
+
+    Usage:
+        import btr
+        client = btr.BarterClient(network="sepolia")
+        score = client.trust.get_score("0x...")
+        profile = client.trust.get_profile("0x...")
+    """
+
+    def __init__(self,
+                 rpc_url: Optional[str] = None,
+                 network: str = "sepolia",
+                 private_key: Optional[str] = None):
+        self.network = network
+
+        # Resolve RPC URL
+        url = rpc_url or os.environ.get("ALCHEMY_RPC_URL") or DEFAULT_RPC
+        self._w3 = Web3(Web3.HTTPProvider(url))
+
+        # Resolve private key
+        pk = private_key or os.environ.get("DEPLOYER_PRIVATE_KEY")
+
+        # Load contracts
+        addresses = CONTRACTS.get(network, {})
+        contracts = {}
+
+        for name in ["BarterCore", "BTRTrust", "BTRCredit"]:
+            addr = addresses.get(name)
+            abi = ABIS.get(name, [])
+            if addr and abi and self._w3.is_connected():
+                try:
+                    contracts[name] = self._w3.eth.contract(
+                        address=self._w3.to_checksum_address(addr),
+                        abi=abi
+                    )
+                except Exception:
+                    contracts[name] = None
+            else:
+                contracts[name] = None
+
+        # Initialize sub-clients
+        self.trust = TrustClient(self._w3, contracts)
+        self.trade = TradeClient(self._w3, contracts, pk)
+        self.credit = CreditClient(self._w3, contracts)
+        self.compliance = ComplianceClient(self._w3, contracts)
+
+    @property
+    def w3(self) -> Web3:
+        """Access the underlying Web3 instance."""
+        return self._w3
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if connected to the network."""
+        try:
+            return self._w3.is_connected()
+        except Exception:
+            return False

barter_sdk-1.0.0/btr/compliance.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+from typing import List
+from btr.types import AnomalyFlag, VelocityReport, ClusterReport, ComplianceReport
+from btr.exceptions import InvalidAddressError
+
+class ComplianceClient:
+    VELOCITY_THRESHOLD_24H = 20
+    VELOCITY_THRESHOLD_7D = 100
+    CONCENTRATION_THRESHOLD = 0.9
+
+    def __init__(self, w3, contracts):
+        self._w3 = w3
+        self._core = contracts.get("BarterCore")
+        self._trust = contracts.get("BTRTrust")
+
+    def _validate_address(self, address: str) -> str:
+        if not address or not address.startswith("0x") or len(address) != 42:
+            raise InvalidAddressError(f"Invalid address: {address}")
+        return self._w3.to_checksum_address(address)
+
+    def get_flags(self, address: str) -> List[AnomalyFlag]:
+        """Analyze address for behavioral anomalies."""
+        self._validate_address(address)
+        flags = []
+        # Would analyze on-chain data for anomalies:
+        # - Rapid cycling (many trades in short time)
+        # - Reciprocal washing (A->B->A pattern)
+        # - Score inflation attempts
+        return flags
+
+    def get_velocity(self, address: str) -> VelocityReport:
+        """Get trading velocity metrics."""
+        addr = self._validate_address(address)
+        return VelocityReport(
+            address=addr,
+            trades_24h=0,
+            trades_7d=0,
+            trades_30d=0,
+            avg_amount_sats=0,
+            is_elevated=False
+        )
+
+    def detect_isolation(self, address: str, depth: int = 2) -> ClusterReport:
+        """Detect graph isolation / cluster analysis."""
+        addr = self._validate_address(address)
+        return ClusterReport(
+            address=addr,
+            cluster_size=0,
+            isolation_score=0.0,
+            connected_addresses=[],
+            depth_analyzed=depth
+        )
+
+    def full_report(self, address: str) -> ComplianceReport:
+        """Generate full compliance report for an address."""
+        addr = self._validate_address(address)
+        return ComplianceReport(
+            address=addr,
+            flags=self.get_flags(addr),
+            velocity=self.get_velocity(addr),
+            cluster=self.detect_isolation(addr),
+            risk_level="low",
+            generated_at=datetime.utcnow()
+        )

barter_sdk-1.0.0/btr/constants.py

@@ -0,0 +1,32 @@
+import json
+import os
+
+SEPOLIA_CHAIN_ID = 11155111
+DEFAULT_RPC = "https://eth-sepolia.g.alchemy.com/v2/demo"
+MIN_TRADE_SATS = 1000
+MAX_PAIR_TRUST = 5
+TRADE_EXPIRY_SECONDS = 7 * 24 * 3600
+
+# Contract addresses (Sepolia deployment)
+CONTRACTS = {
+    "sepolia": {
+        "BarterCore": "0x0000000000000000000000000000000000000001",
+        "BTRTrust": "0x0000000000000000000000000000000000000002",
+        "BTRCredit": "0x0000000000000000000000000000000000000003",
+    }
+}
+
+def _load_abi(name: str) -> list:
+    abi_dir = os.path.join(os.path.dirname(__file__), "abis")
+    path = os.path.join(abi_dir, f"{name}.json")
+    if os.path.exists(path):
+        with open(path) as f:
+            data = json.load(f)
+            return data if isinstance(data, list) else data.get("abi", [])
+    return []
+
+ABIS = {
+    "BarterCore": _load_abi("BarterCore"),
+    "BTRTrust": _load_abi("BTRTrust"),
+    "BTRCredit": _load_abi("BTRCredit"),
+}

barter_sdk-1.0.0/btr/credit.py

@@ -0,0 +1,29 @@
+from btr.exceptions import InvalidAddressError
+
+class CreditClient:
+    def __init__(self, w3, contracts):
+        self._w3 = w3
+        self._credit = contracts.get("BTRCredit")
+
+    def _validate_address(self, address: str) -> str:
+        if not address or not address.startswith("0x") or len(address) != 42:
+            raise InvalidAddressError(f"Invalid address: {address}")
+        return self._w3.to_checksum_address(address)
+
+    def balance_of(self, address: str) -> int:
+        """Get BTR-C balance in wei."""
+        addr = self._validate_address(address)
+        if self._credit is None:
+            return 0
+        return self._credit.functions.balanceOf(addr).call()
+
+    def balance_formatted(self, address: str) -> float:
+        """Get BTR-C balance in human-readable format."""
+        raw = self.balance_of(address)
+        return raw / 1e18
+
+    def total_supply(self) -> int:
+        """Get total BTR-C supply."""
+        if self._credit is None:
+            return 0
+        return self._credit.functions.totalSupply().call()

barter_sdk-1.0.0/btr/exceptions.py

@@ -0,0 +1,27 @@
+class BarterError(Exception):
+    """Base exception for all BTR SDK errors."""
+    pass
+
+class InvalidAddressError(BarterError):
+    """Raised when an Ethereum address is invalid."""
+    pass
+
+class TradeNotFoundError(BarterError):
+    """Raised when a trade ID does not exist on-chain."""
+    pass
+
+class PreimageMismatchError(BarterError):
+    """Raised when SHA256(preimage) != payment_hash."""
+    pass
+
+class InsufficientAmountError(BarterError):
+    """Raised when trade amount is below minimum (1000 sats)."""
+    pass
+
+class SelfTradeError(BarterError):
+    """Raised when attempting to trade with yourself."""
+    pass
+
+class NetworkError(BarterError):
+    """Raised on RPC/network connectivity issues."""
+    pass

barter_sdk-1.0.0/btr/trade.py

@@ -0,0 +1,185 @@
+import hashlib
+from datetime import datetime
+from typing import List
+from btr.types import Trade, TradeStatus
+from btr.exceptions import (
+    InvalidAddressError, TradeNotFoundError,
+    PreimageMismatchError, InsufficientAmountError, SelfTradeError
+)
+
+class TradeClient:
+    MIN_TRADE_SATS = 1000
+
+    def __init__(self, w3, contracts, private_key=None):
+        self._w3 = w3
+        self._core = contracts.get("BarterCore")
+        self._pk = private_key
+        self._account = None
+        if private_key and w3:
+            self._account = w3.eth.account.from_key(private_key)
+
+    def _validate_address(self, address: str) -> str:
+        if not address or not isinstance(address, str):
+            raise InvalidAddressError(f"Invalid address: {address}")
+        if not address.startswith("0x") or len(address) != 42:
+            raise InvalidAddressError(f"Invalid address format: {address}")
+        try:
+            return self._w3.to_checksum_address(address)
+        except Exception:
+            raise InvalidAddressError(f"Invalid address: {address}")
+
+    def _get_sender(self) -> str:
+        if self._account:
+            return self._account.address
+        accounts = self._w3.eth.accounts
+        if accounts:
+            return accounts[0]
+        raise Exception("No account available. Provide a private_key.")
+
+    def propose(self, counterparty: str, payment_hash: str,
+                amount_sats: int, category: str = "", description: str = "") -> str:
+        """Propose a new trade. Returns trade ID."""
+        sender = self._get_sender()
+        cp = self._validate_address(counterparty)
+
+        if cp.lower() == sender.lower():
+            raise SelfTradeError("Cannot trade with yourself")
+        if amount_sats < self.MIN_TRADE_SATS:
+            raise InsufficientAmountError(f"Amount {amount_sats} below minimum {self.MIN_TRADE_SATS} sats")
+        if len(description) > 200:
+            raise ValueError("Description too long (max 200 chars)")
+
+        if self._core is None:
+            raise Exception("Contract not connected")
+
+        tx = self._core.functions.proposeTrade(
+            cp, bytes.fromhex(payment_hash[2:]) if payment_hash.startswith("0x") else bytes.fromhex(payment_hash),
+            amount_sats, category, description
+        )
+
+        if self._pk:
+            built = tx.build_transaction({
+                "from": sender,
+                "nonce": self._w3.eth.get_transaction_count(sender),
+                "gas": 300000,
+            })
+            signed = self._w3.eth.account.sign_transaction(built, self._pk)
+            tx_hash = self._w3.eth.send_raw_transaction(signed.raw_transaction)
+            receipt = self._w3.eth.wait_for_transaction_receipt(tx_hash)
+        else:
+            receipt = tx.transact({"from": sender})
+            receipt = self._w3.eth.wait_for_transaction_receipt(receipt)
+
+        # Extract tradeId from event logs
+        logs = self._core.events.TradeProposed().process_receipt(receipt)
+        if logs:
+            return "0x" + logs[0]["args"]["tradeId"].hex()
+        return receipt["transactionHash"].hex()
+
+    def accept(self, trade_id: str) -> dict:
+        """Accept a proposed trade."""
+        tid = bytes.fromhex(trade_id[2:]) if trade_id.startswith("0x") else bytes.fromhex(trade_id)
+        sender = self._get_sender()
+        tx = self._core.functions.acceptTrade(tid)
+
+        if self._pk:
+            built = tx.build_transaction({
+                "from": sender,
+                "nonce": self._w3.eth.get_transaction_count(sender),
+                "gas": 200000,
+            })
+            signed = self._w3.eth.account.sign_transaction(built, self._pk)
+            tx_hash = self._w3.eth.send_raw_transaction(signed.raw_transaction)
+            return dict(self._w3.eth.wait_for_transaction_receipt(tx_hash))
+        else:
+            tx_hash = tx.transact({"from": sender})
+            return dict(self._w3.eth.wait_for_transaction_receipt(tx_hash))
+
+    def settle(self, trade_id: str, preimage: str) -> dict:
+        """Settle a trade with Lightning preimage. Verifies SHA256."""
+        tid = bytes.fromhex(trade_id[2:]) if trade_id.startswith("0x") else bytes.fromhex(trade_id)
+        pre = bytes.fromhex(preimage[2:]) if preimage.startswith("0x") else bytes.fromhex(preimage)
+
+        # Local verification before submitting
+        trade = self.get(trade_id)
+        expected_hash = trade.payment_hash
+        # The contract uses sha256(abi.encode(preimage))
+        # abi.encode for bytes32 is just the 32 bytes padded
+        computed = hashlib.sha256(pre.rjust(32, b'\x00')).hexdigest()
+        if not expected_hash.lower().endswith(computed.lower()):
+            raise PreimageMismatchError("SHA256(preimage) does not match payment_hash")
+
+        sender = self._get_sender()
+        tx = self._core.functions.settleTrade(tid, pre)
+
+        if self._pk:
+            built = tx.build_transaction({
+                "from": sender,
+                "nonce": self._w3.eth.get_transaction_count(sender),
+                "gas": 400000,
+            })
+            signed = self._w3.eth.account.sign_transaction(built, self._pk)
+            tx_hash = self._w3.eth.send_raw_transaction(signed.raw_transaction)
+            return dict(self._w3.eth.wait_for_transaction_receipt(tx_hash))
+        else:
+            tx_hash = tx.transact({"from": sender})
+            return dict(self._w3.eth.wait_for_transaction_receipt(tx_hash))
+
+    def dispute(self, trade_id: str) -> dict:
+        """Dispute a trade."""
+        tid = bytes.fromhex(trade_id[2:]) if trade_id.startswith("0x") else bytes.fromhex(trade_id)
+        sender = self._get_sender()
+        tx = self._core.functions.disputeTrade(tid)
+
+        if self._pk:
+            built = tx.build_transaction({
+                "from": sender,
+                "nonce": self._w3.eth.get_transaction_count(sender),
+                "gas": 200000,
+            })
+            signed = self._w3.eth.account.sign_transaction(built, self._pk)
+            tx_hash = self._w3.eth.send_raw_transaction(signed.raw_transaction)
+            return dict(self._w3.eth.wait_for_transaction_receipt(tx_hash))
+        else:
+            tx_hash = tx.transact({"from": sender})
+            return dict(self._w3.eth.wait_for_transaction_receipt(tx_hash))
+
+    def get(self, trade_id: str) -> Trade:
+        """Get trade details by ID."""
+        tid = bytes.fromhex(trade_id[2:]) if trade_id.startswith("0x") else bytes.fromhex(trade_id)
+        if self._core is None:
+            raise TradeNotFoundError(f"Trade {trade_id} not found")
+        result = self._core.functions.trades(tid).call()
+        if result[6] == 0:  # createdAt == 0
+            raise TradeNotFoundError(f"Trade {trade_id} not found")
+
+        status_map = {0: TradeStatus.PROPOSED, 1: TradeStatus.ACCEPTED,
+                      2: TradeStatus.SETTLED, 3: TradeStatus.DISPUTED, 4: TradeStatus.EXPIRED}
+
+        return Trade(
+            trade_id="0x" + result[0].hex(),
+            party_a=result[1],
+            party_b=result[2],
+            payment_hash="0x" + result[3].hex(),
+            amount_sats=result[4],
+            status=status_map.get(result[5], TradeStatus.PROPOSED),
+            created_at=datetime.fromtimestamp(result[6]),
+            accepted_at=datetime.fromtimestamp(result[7]) if result[7] > 0 else None,
+            settled_at=datetime.fromtimestamp(result[8]) if result[8] > 0 else None,
+            category=result[9],
+            description=result[10],
+        )
+
+    def list_by_address(self, address: str) -> List[Trade]:
+        """Get all trades for an address."""
+        addr = self._validate_address(address)
+        if self._core is None:
+            return []
+        trade_ids = self._core.functions.getTradesByAddress(addr).call()
+        trades = []
+        for tid in trade_ids:
+            try:
+                trades.append(self.get("0x" + tid.hex()))
+            except TradeNotFoundError:
+                continue
+        return trades

barter_sdk-1.0.0/btr/trust.py

@@ -0,0 +1,75 @@
+from datetime import datetime
+from typing import List, Optional
+from btr.types import TrustProfile, ScoreEvent
+from btr.exceptions import InvalidAddressError
+
+class TrustClient:
+    def __init__(self, w3, contracts):
+        self._w3 = w3
+        self._trust = contracts.get("BTRTrust")
+        self._core = contracts.get("BarterCore")
+
+    def _validate_address(self, address: str) -> str:
+        if not address or not isinstance(address, str):
+            raise InvalidAddressError(f"Invalid address: {address}")
+        if not address.startswith("0x") or len(address) != 42:
+            raise InvalidAddressError(f"Invalid address format: {address}")
+        try:
+            return self._w3.to_checksum_address(address)
+        except Exception:
+            raise InvalidAddressError(f"Invalid address: {address}")
+
+    def get_score(self, address: str) -> int:
+        """Get the BTR-Trust score for a wallet address."""
+        addr = self._validate_address(address)
+        if self._trust is None:
+            return 0
+        return self._trust.functions.getScore(addr).call()
+
+    def get_profile(self, address: str) -> TrustProfile:
+        """Get the full trust profile for a wallet address."""
+        addr = self._validate_address(address)
+        if self._trust is None:
+            return TrustProfile(
+                address=addr, score=0, unique_counterparties=0,
+                trade_count=0, completion_rate=0.0
+            )
+        result = self._trust.functions.getTrustProfile(addr).call()
+        score, unique, member_since_ts, trade_count, last_trade_ts = result
+
+        # Calculate completion rate from trade data
+        settled = 0
+        total = 0
+        if self._core:
+            trade_ids = self._core.functions.getTradesByAddress(addr).call()
+            total = len(trade_ids)
+            for tid in trade_ids:
+                trade = self._core.functions.trades(tid).call()
+                if trade[5] == 2:  # Settled status
+                    settled += 1
+
+        completion_rate = (settled / total * 100) if total > 0 else 0.0
+
+        return TrustProfile(
+            address=addr,
+            score=score,
+            unique_counterparties=unique,
+            member_since=datetime.fromtimestamp(member_since_ts) if member_since_ts > 0 else None,
+            trade_count=trade_count,
+            completion_rate=round(completion_rate, 1),
+            last_trade_at=datetime.fromtimestamp(last_trade_ts) if last_trade_ts > 0 else None,
+        )
+
+    def get_history(self, address: str, from_date: Optional[datetime] = None, to_date: Optional[datetime] = None) -> List[ScoreEvent]:
+        """Get score change history for an address."""
+        addr = self._validate_address(address)
+        # Would query ScoreUpdated events from the contract
+        return []
+
+    def get_pair_count(self, addr_a: str, addr_b: str) -> int:
+        """Get the number of trust-counted trades between two addresses."""
+        a = self._validate_address(addr_a)
+        b = self._validate_address(addr_b)
+        if self._trust is None:
+            return 0
+        return self._trust.functions.pairCount(a, b).call()

barter_sdk-1.0.0/btr/types.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+from enum import Enum
+from typing import Optional, List
+from pydantic import BaseModel, Field
+
+class TradeStatus(str, Enum):
+    PROPOSED = "proposed"
+    ACCEPTED = "accepted"
+    SETTLED = "settled"
+    DISPUTED = "disputed"
+    EXPIRED = "expired"
+
+class TrustProfile(BaseModel):
+    address: str
+    score: int
+    unique_counterparties: int
+    member_since: Optional[datetime] = None
+    trade_count: int = 0
+    completion_rate: float = 0.0
+    last_trade_at: Optional[datetime] = None
+
+class Trade(BaseModel):
+    trade_id: str
+    party_a: str
+    party_b: str
+    payment_hash: str
+    amount_sats: int
+    status: TradeStatus
+    created_at: datetime
+    accepted_at: Optional[datetime] = None
+    settled_at: Optional[datetime] = None
+    category: str = ""
+    description: str = ""
+
+class ScoreEvent(BaseModel):
+    block_number: int
+    timestamp: datetime
+    delta: int
+    new_score: int
+    counterparty: str
+    amount_sats: int
+
+class AnomalyFlag(BaseModel):
+    flag_type: str
+    severity: str  # "low", "medium", "high"
+    description: str
+    detected_at: datetime
+    details: dict = Field(default_factory=dict)
+
+class VelocityReport(BaseModel):
+    address: str
+    trades_24h: int
+    trades_7d: int
+    trades_30d: int
+    avg_amount_sats: int
+    is_elevated: bool
+
+class ClusterReport(BaseModel):
+    address: str
+    cluster_size: int
+    isolation_score: float
+    connected_addresses: List[str]
+    depth_analyzed: int
+
+class ComplianceReport(BaseModel):
+    address: str
+    flags: List[AnomalyFlag]
+    velocity: VelocityReport
+    cluster: ClusterReport
+    risk_level: str  # "low", "medium", "high"
+    generated_at: datetime

barter_sdk-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=64.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "barter-sdk"
+version = "1.0.0"
+description = "Proof of Trade Protocol — Python SDK for BTR-Trust soulbound reputation"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [{name = "TheBarmaEffect"}]
+keywords = ["barter", "bitcoin", "lightning", "trust", "reputation", "web3"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "web3>=6.0.0",
+    "pydantic>=2.0.0",
+    "python-dotenv>=1.0.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-cov", "pytest-asyncio"]
+
+[tool.setuptools.packages.find]
+include = ["btr*"]

barter_sdk-1.0.0/setup.cfg

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

barter_sdk-1.0.0/tests/test_compliance.py

@@ -0,0 +1,44 @@
+import pytest
+from btr.compliance import ComplianceClient
+from btr.types import ComplianceReport, VelocityReport, ClusterReport
+from btr.exceptions import InvalidAddressError
+from unittest.mock import MagicMock
+
+VALID_ADDR = "0x742d35Cc6634C0532925a3b844Bc9e7595f3F9a0"
+
+@pytest.fixture
+def compliance_client():
+    w3 = MagicMock()
+    w3.to_checksum_address = lambda x: x
+    contracts = {"BarterCore": None, "BTRTrust": None}
+    return ComplianceClient(w3, contracts)
+
+class TestGetFlags:
+    def test_returns_list(self, compliance_client):
+        flags = compliance_client.get_flags(VALID_ADDR)
+        assert isinstance(flags, list)
+
+    def test_invalid_address_raises(self, compliance_client):
+        with pytest.raises(InvalidAddressError):
+            compliance_client.get_flags("bad")
+
+class TestFullReport:
+    def test_returns_compliance_report(self, compliance_client):
+        report = compliance_client.full_report(VALID_ADDR)
+        assert isinstance(report, ComplianceReport)
+
+    def test_has_all_fields(self, compliance_client):
+        report = compliance_client.full_report(VALID_ADDR)
+        assert hasattr(report, "flags")
+        assert hasattr(report, "velocity")
+        assert hasattr(report, "cluster")
+        assert hasattr(report, "risk_level")
+        assert hasattr(report, "generated_at")
+
+    def test_velocity_report(self, compliance_client):
+        velocity = compliance_client.get_velocity(VALID_ADDR)
+        assert isinstance(velocity, VelocityReport)
+
+    def test_cluster_report(self, compliance_client):
+        cluster = compliance_client.detect_isolation(VALID_ADDR)
+        assert isinstance(cluster, ClusterReport)

barter_sdk-1.0.0/tests/test_integration.py

@@ -0,0 +1,28 @@
+import pytest
+from btr.client import BarterClient
+
+class TestBarterClient:
+    def test_init_default(self):
+        client = BarterClient()
+        assert client.network == "sepolia"
+        assert client.trust is not None
+        assert client.trade is not None
+        assert client.credit is not None
+        assert client.compliance is not None
+
+    def test_subclients_accessible(self):
+        client = BarterClient()
+        assert hasattr(client, "trust")
+        assert hasattr(client, "trade")
+        assert hasattr(client, "credit")
+        assert hasattr(client, "compliance")
+
+    def test_version(self):
+        import btr
+        assert btr.__version__ == "1.0.0"
+
+    def test_imports(self):
+        from btr import BarterClient, TrustProfile, Trade, TradeStatus
+        from btr import BarterError, InvalidAddressError
+        assert BarterClient is not None
+        assert TrustProfile is not None

barter_sdk-1.0.0/tests/test_trade.py

@@ -0,0 +1,44 @@
+import pytest
+from btr.trade import TradeClient
+from btr.types import Trade
+from btr.exceptions import SelfTradeError, InsufficientAmountError, InvalidAddressError
+from unittest.mock import MagicMock
+
+ALICE = "0x742d35Cc6634C0532925a3b844Bc9e7595f3F9a0"
+BOB = "0x8ba1f109551bD432803012645Ac136ddd64DBA72"
+
+@pytest.fixture
+def trade_client():
+    w3 = MagicMock()
+    w3.to_checksum_address = lambda x: x
+    w3.eth.accounts = [ALICE]
+    contracts = {"BarterCore": None}
+    return TradeClient(w3, contracts)
+
+class TestPropose:
+    def test_self_trade_raises(self, trade_client):
+        with pytest.raises(SelfTradeError):
+            trade_client.propose(ALICE, "0x" + "ab" * 32, 5000)
+
+    def test_below_min_raises(self, trade_client):
+        with pytest.raises(InsufficientAmountError):
+            trade_client.propose(BOB, "0x" + "ab" * 32, 999)
+
+    def test_invalid_address_raises(self, trade_client):
+        with pytest.raises(InvalidAddressError):
+            trade_client.propose("bad", "0x" + "ab" * 32, 5000)
+
+    def test_long_description_raises(self, trade_client):
+        with pytest.raises(ValueError):
+            trade_client.propose(BOB, "0x" + "ab" * 32, 5000, description="x" * 201)
+
+class TestGet:
+    def test_not_found_raises(self, trade_client):
+        from btr.exceptions import TradeNotFoundError
+        with pytest.raises(TradeNotFoundError):
+            trade_client.get("0x" + "00" * 32)
+
+class TestListByAddress:
+    def test_returns_list(self, trade_client):
+        result = trade_client.list_by_address(BOB)
+        assert isinstance(result, list)

barter_sdk-1.0.0/tests/test_trust.py

@@ -0,0 +1,64 @@
+import pytest
+from btr.trust import TrustClient
+from btr.types import TrustProfile
+from btr.exceptions import InvalidAddressError
+from unittest.mock import MagicMock
+
+VALID_ADDR = "0x742d35Cc6634C0532925a3b844Bc9e7595f3F9a0"
+ZERO_ADDR = "0x0000000000000000000000000000000000000000"
+
+@pytest.fixture
+def trust_client():
+    w3 = MagicMock()
+    w3.to_checksum_address = lambda x: x
+    contracts = {"BTRTrust": None, "BarterCore": None}
+    return TrustClient(w3, contracts)
+
+class TestGetScore:
+    def test_valid_address_returns_int(self, trust_client):
+        score = trust_client.get_score(VALID_ADDR)
+        assert isinstance(score, int)
+        assert score == 0
+
+    def test_invalid_address_raises(self, trust_client):
+        with pytest.raises(InvalidAddressError):
+            trust_client.get_score("invalid")
+
+    def test_empty_address_raises(self, trust_client):
+        with pytest.raises(InvalidAddressError):
+            trust_client.get_score("")
+
+    def test_short_address_raises(self, trust_client):
+        with pytest.raises(InvalidAddressError):
+            trust_client.get_score("0x123")
+
+class TestGetProfile:
+    def test_returns_trust_profile(self, trust_client):
+        profile = trust_client.get_profile(VALID_ADDR)
+        assert isinstance(profile, TrustProfile)
+
+    def test_all_required_fields(self, trust_client):
+        profile = trust_client.get_profile(VALID_ADDR)
+        assert hasattr(profile, "address")
+        assert hasattr(profile, "score")
+        assert hasattr(profile, "unique_counterparties")
+        assert hasattr(profile, "trade_count")
+        assert hasattr(profile, "completion_rate")
+
+    def test_invalid_address_raises(self, trust_client):
+        with pytest.raises(InvalidAddressError):
+            trust_client.get_profile("bad")
+
+class TestGetHistory:
+    def test_returns_list(self, trust_client):
+        result = trust_client.get_history(VALID_ADDR)
+        assert isinstance(result, list)
+
+    def test_with_date_filters(self, trust_client):
+        from datetime import datetime
+        result = trust_client.get_history(
+            VALID_ADDR,
+            from_date=datetime(2024, 1, 1),
+            to_date=datetime(2024, 12, 31)
+        )
+        assert isinstance(result, list)