ap2-algorand 0.1.0__tar.gz

ap2_algorand-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: ap2-algorand
+Version: 0.1.0
+Summary: Google AP2 × Algorand adapter — settle x402 payments from AP2 CartMandate/PaymentMandate
+License-Expression: MIT
+Keywords: algorand,x402,usdc,ap2,agent-payments,ai-agent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: py-algorand-sdk<3.0,>=2.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: ap2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+
+# ap2-algorand
+
+**Google AP2 × Algorand x402 adapter** — settle AI agent payments on Algorand from an AP2 `PaymentMandate`.
+
+Bridges the [Google Agent Payments Protocol (AP2)](https://github.com/google-agentic-commerce/AP2) with non-custodial USDC payments on Algorand, enforced by AVM MandateContracts.
+
+## Install
+
+```bash
+pip install ap2-algorand
+```
+
+## Quick start
+
+### Buyer: advertise x402 Algorand in a CartMandate
+
+```python
+from ap2_algorand import AlgorandUsdcMethodData, X402_METHOD_NAME
+from ap2.types.payment_request import PaymentMethodData
+
+method = PaymentMethodData(
+    supported_methods=X402_METHOD_NAME,   # "https://www.x402.org/"
+    data=AlgorandUsdcMethodData(
+        mandate_app_id=3_498_113_854,     # agent's MandateContract app ID
+        asset_id=31_566_704,              # mainnet USDC ASA
+        network="mainnet",
+        x402_endpoint="https://api.example.com/weather",
+    ).model_dump(),
+)
+```
+
+### Buyer: parse payment args from a CartMandate
+
+```python
+from ap2_algorand import cart_to_payment_args
+
+args = cart_to_payment_args(cart_mandate)
+# args.mandate_app_id  → int
+# args.amount_micro_usdc → int  (e.g. 10_000 for $0.01 USDC)
+# args.asset_id        → int
+# args.x402_endpoint   → str
+```
+
+### Merchant: submit payment and get a PaymentReceipt
+
+```python
+import os
+from ap2_algorand import settle
+
+receipt = settle(
+    payment_mandate=payment_mandate,
+    algod_url="https://mainnet-api.algonode.cloud",
+)
+txid = receipt.payment_status.network_confirmation_id
+# txid == Algorand transaction ID (network IS the ledger)
+```
+
+### Lower-level: submit without AP2 types
+
+```python
+from ap2_algorand import settle_raw
+
+txid = settle_raw(
+    x_payment="<base64-msgpack-signed-tx>",
+    algod_url="https://mainnet-api.algonode.cloud",
+)
+```
+
+## How it maps to AP2
+
+| AP2 field | Algorand value |
+|---|---|
+| `payment_response.method_name` | `https://www.x402.org/` |
+| `payment_response.details["value"]` | `base64(msgpack(SignedTransaction))` |
+| `merchant_confirmation_id` | Algorand txid |
+| `psp_confirmation_id` | Algorand txid (AVM is the PSP) |
+| `network_confirmation_id` | Algorand txid (Algorand is the network) |
+| OTP challenge | skipped — AVM MandateContract enforces limits |
+
+## Dependencies
+
+- `py-algorand-sdk >= 2.0`
+- `pydantic >= 2.0`
+- `ap2` — optional, only needed for `settle()` return type (`PaymentReceipt`)
+
+## License
+
+MIT © Algo Wallet

ap2_algorand-0.1.0/README.md

@@ -0,0 +1,88 @@
+# ap2-algorand
+
+**Google AP2 × Algorand x402 adapter** — settle AI agent payments on Algorand from an AP2 `PaymentMandate`.
+
+Bridges the [Google Agent Payments Protocol (AP2)](https://github.com/google-agentic-commerce/AP2) with non-custodial USDC payments on Algorand, enforced by AVM MandateContracts.
+
+## Install
+
+```bash
+pip install ap2-algorand
+```
+
+## Quick start
+
+### Buyer: advertise x402 Algorand in a CartMandate
+
+```python
+from ap2_algorand import AlgorandUsdcMethodData, X402_METHOD_NAME
+from ap2.types.payment_request import PaymentMethodData
+
+method = PaymentMethodData(
+    supported_methods=X402_METHOD_NAME,   # "https://www.x402.org/"
+    data=AlgorandUsdcMethodData(
+        mandate_app_id=3_498_113_854,     # agent's MandateContract app ID
+        asset_id=31_566_704,              # mainnet USDC ASA
+        network="mainnet",
+        x402_endpoint="https://api.example.com/weather",
+    ).model_dump(),
+)
+```
+
+### Buyer: parse payment args from a CartMandate
+
+```python
+from ap2_algorand import cart_to_payment_args
+
+args = cart_to_payment_args(cart_mandate)
+# args.mandate_app_id  → int
+# args.amount_micro_usdc → int  (e.g. 10_000 for $0.01 USDC)
+# args.asset_id        → int
+# args.x402_endpoint   → str
+```
+
+### Merchant: submit payment and get a PaymentReceipt
+
+```python
+import os
+from ap2_algorand import settle
+
+receipt = settle(
+    payment_mandate=payment_mandate,
+    algod_url="https://mainnet-api.algonode.cloud",
+)
+txid = receipt.payment_status.network_confirmation_id
+# txid == Algorand transaction ID (network IS the ledger)
+```
+
+### Lower-level: submit without AP2 types
+
+```python
+from ap2_algorand import settle_raw
+
+txid = settle_raw(
+    x_payment="<base64-msgpack-signed-tx>",
+    algod_url="https://mainnet-api.algonode.cloud",
+)
+```
+
+## How it maps to AP2
+
+| AP2 field | Algorand value |
+|---|---|
+| `payment_response.method_name` | `https://www.x402.org/` |
+| `payment_response.details["value"]` | `base64(msgpack(SignedTransaction))` |
+| `merchant_confirmation_id` | Algorand txid |
+| `psp_confirmation_id` | Algorand txid (AVM is the PSP) |
+| `network_confirmation_id` | Algorand txid (Algorand is the network) |
+| OTP challenge | skipped — AVM MandateContract enforces limits |
+
+## Dependencies
+
+- `py-algorand-sdk >= 2.0`
+- `pydantic >= 2.0`
+- `ap2` — optional, only needed for `settle()` return type (`PaymentReceipt`)
+
+## License
+
+MIT © Algo Wallet

ap2_algorand-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ap2-algorand"
+version = "0.1.0"
+description = "Google AP2 × Algorand adapter — settle x402 payments from AP2 CartMandate/PaymentMandate"
+requires-python = ">=3.10"
+license = "MIT"
+readme = "README.md"
+keywords = ["algorand", "x402", "usdc", "ap2", "agent-payments", "ai-agent"]
+dependencies = [
+    "py-algorand-sdk>=2.0,<3.0",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+ap2 = []   # pip install ap2  (from google-agentic-commerce/AP2 when published)
+dev = ["pytest>=8.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"

ap2_algorand-0.1.0/setup.cfg

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

ap2_algorand-0.1.0/src/ap2_algorand/__init__.py

@@ -0,0 +1,63 @@
+"""ap2-algorand — Google AP2 × Algorand x402 adapter.
+
+Bridges the `Google Agent Payments Protocol (AP2)
+<https://github.com/google-agentic-commerce/AP2>`_ with Algorand x402
+payments.
+
+**Buyer side** — build a ``PaymentMethodData`` for your ``CartMandate``::
+
+    from ap2_algorand import AlgorandUsdcMethodData, X402_METHOD_NAME
+    from ap2.types.payment_request import PaymentMethodData
+
+    method = PaymentMethodData(
+        supported_methods=X402_METHOD_NAME,
+        data=AlgorandUsdcMethodData(
+            mandate_app_id=3_498_113_854,
+            asset_id=31_566_704,           # mainnet USDC
+            network="mainnet",
+            x402_endpoint="https://api.example.com/premium",
+        ).model_dump(),
+    )
+
+**Buyer side** — extract payment args from a ``CartMandate``::
+
+    from ap2_algorand import cart_to_payment_args
+
+    args = cart_to_payment_args(cart_mandate)
+    # args.mandate_app_id, args.amount_micro_usdc, args.asset_id, args.x402_endpoint
+
+**Merchant side** — submit payment and get ``PaymentReceipt``::
+
+    from ap2_algorand import settle
+
+    receipt = settle(payment_mandate, algod_url="https://mainnet-api.algonode.cloud")
+    # receipt.payment_status.network_confirmation_id == Algorand txid
+"""
+
+__version__ = "0.1.0"
+
+from ap2_algorand.payment_method import (
+    AlgorandUsdcMethodData,
+    X402_METHOD_NAME,
+    USDC_MAINNET_ASA_ID,
+    USDC_TESTNET_ASA_ID,
+)
+from ap2_algorand.cart_adapter import (
+    AlgorandPaymentArgs,
+    cart_to_payment_args,
+)
+from ap2_algorand.settle import settle, settle_raw
+
+__all__ = [
+    # Payment method
+    "AlgorandUsdcMethodData",
+    "X402_METHOD_NAME",
+    "USDC_MAINNET_ASA_ID",
+    "USDC_TESTNET_ASA_ID",
+    # Cart adapter
+    "AlgorandPaymentArgs",
+    "cart_to_payment_args",
+    # Settlement
+    "settle",
+    "settle_raw",
+]

ap2_algorand-0.1.0/src/ap2_algorand/cart_adapter.py

@@ -0,0 +1,89 @@
+"""cart_to_payment_args — extract Algorand payment parameters from an AP2 CartMandate.
+
+Converts the merchant-signed AP2 ``CartMandate`` into the concrete arguments
+needed to build and sign an Algorand MandateContract.pay() transaction.
+
+Usage::
+
+    from ap2_algorand import cart_to_payment_args
+
+    args = cart_to_payment_args(cart_mandate)
+    # args.mandate_app_id, args.amount_micro_usdc, args.asset_id, args.x402_endpoint
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ap2_algorand.payment_method import AlgorandUsdcMethodData, X402_METHOD_NAME
+
+
+@dataclass
+class AlgorandPaymentArgs:
+    """Parameters extracted from an AP2 CartMandate for Algorand payment."""
+
+    mandate_app_id: int
+    """Algorand application ID of the buyer's MandateContract."""
+
+    asset_id: int
+    """Algorand ASA ID for the payment token (USDC)."""
+
+    amount_micro_usdc: int
+    """Payment amount in micro-USDC (value × 1_000_000)."""
+
+    x402_endpoint: str
+    """The x402-gated endpoint being paid for."""
+
+    network: str
+    """Algorand network ('mainnet' or 'testnet')."""
+
+
+def cart_to_payment_args(cart_mandate: Any) -> AlgorandPaymentArgs:
+    """Extract Algorand payment parameters from an AP2 CartMandate.
+
+    Locates the ``https://www.x402.org/`` entry in the cart's
+    ``payment_request.method_data``, parses it as
+    :class:`~ap2_algorand.AlgorandUsdcMethodData`, and converts the cart
+    total to micro-USDC.
+
+    Args:
+        cart_mandate: An AP2 ``CartMandate`` instance (or any object with a
+            compatible ``.contents.payment_request`` attribute).
+
+    Returns:
+        :class:`AlgorandPaymentArgs` ready to pass to the x402 buyer client.
+
+    Raises:
+        ValueError: If no x402 Algorand payment method is found in the cart.
+    """
+    payment_request = cart_mandate.contents.payment_request
+
+    # Locate the x402 payment method entry
+    x402_method_data: AlgorandUsdcMethodData | None = None
+    for method in payment_request.method_data:
+        if method.supported_methods == X402_METHOD_NAME:
+            data = method.data or {}
+            x402_method_data = AlgorandUsdcMethodData(**data)
+            break
+
+    if x402_method_data is None:
+        available = [m.supported_methods for m in payment_request.method_data]
+        raise ValueError(
+            f"No x402 Algorand payment method found in CartMandate. "
+            f"Available methods: {available}"
+        )
+
+    # Convert total to micro-USDC.
+    # PaymentCurrencyAmount.value is a float USD amount; 1 USDC = 1_000_000 µUSDC.
+    total = payment_request.details.total
+    amount_float: float = float(total.amount.value)
+    amount_micro_usdc = round(amount_float * 1_000_000)
+
+    return AlgorandPaymentArgs(
+        mandate_app_id=x402_method_data.mandate_app_id,
+        asset_id=x402_method_data.asset_id,
+        amount_micro_usdc=amount_micro_usdc,
+        x402_endpoint=x402_method_data.x402_endpoint,
+        network=x402_method_data.network,
+    )

ap2_algorand-0.1.0/src/ap2_algorand/payment_method.py

@@ -0,0 +1,71 @@
+"""AlgorandUsdcMethodData — PaymentMethodData.data for x402 on Algorand.
+
+Use this as the ``data`` dict inside a W3C ``PaymentMethodData`` object when
+constructing an AP2 ``CartMandate`` or ``PaymentRequest`` that accepts x402
+payments settled on Algorand.
+
+Example::
+
+    from ap2.types.payment_request import PaymentMethodData
+    from ap2_algorand import AlgorandUsdcMethodData
+
+    method = PaymentMethodData(
+        supported_methods="https://www.x402.org/",
+        data=AlgorandUsdcMethodData(
+            mandate_app_id=3498113854,
+            asset_id=31_566_704,
+            network="mainnet",
+            x402_endpoint="https://api.example.com/premium",
+        ).model_dump(),
+    )
+"""
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+X402_METHOD_NAME = "https://www.x402.org/"
+
+USDC_MAINNET_ASA_ID = 31_566_704
+USDC_TESTNET_ASA_ID = 10_458_941
+
+
+class AlgorandUsdcMethodData(BaseModel):
+    """Configuration data for an Algorand / x402 payment method.
+
+    Carried in ``PaymentMethodData.data`` with
+    ``supported_methods="https://www.x402.org/"``.
+    """
+
+    mandate_app_id: int = Field(
+        ...,
+        description=(
+            "Algorand application ID of the agent's MandateContract. "
+            "The AVM enforces per-tx and velocity caps for this agent."
+        ),
+    )
+    asset_id: int = Field(
+        ...,
+        description=(
+            "Algorand ASA ID for the payment token. "
+            f"Mainnet USDC = {USDC_MAINNET_ASA_ID}, "
+            f"testnet USDC = {USDC_TESTNET_ASA_ID}."
+        ),
+    )
+    network: Literal["mainnet", "testnet"] = Field(
+        "mainnet",
+        description="Algorand network.",
+    )
+    x402_endpoint: str = Field(
+        ...,
+        description=(
+            "The x402-gated API endpoint URL that will receive the payment. "
+            "The merchant verifies the signed transaction references this endpoint."
+        ),
+    )
+
+    @property
+    def usdc_asset_id(self) -> int:
+        """Convenience: returns the canonical USDC ASA ID for the network."""
+        return USDC_MAINNET_ASA_ID if self.network == "mainnet" else USDC_TESTNET_ASA_ID

ap2_algorand-0.1.0/src/ap2_algorand/settle.py

@@ -0,0 +1,154 @@
+"""settle — submit an x402 Algorand payment and return an AP2 PaymentReceipt.
+
+This is the merchant-side counterpart: given an AP2 ``PaymentMandate`` whose
+``payment_response.details["value"]`` carries a base64-encoded msgpack
+``SignedTransaction`` (the x402 payment header), submit it to Algorand and
+return a fully-formed AP2 ``PaymentReceipt``.
+
+The Algorand transaction ID serves as all three confirmation IDs:
+
+* ``merchant_confirmation_id`` — the merchant records the txid
+* ``psp_confirmation_id``      — Algorand IS the PSP (self-custodial mandate)
+* ``network_confirmation_id``  — Algorand IS the network
+
+Usage (merchant payment processor agent)::
+
+    import os
+    from ap2_algorand import settle
+
+    receipt = settle(
+        payment_mandate=payment_mandate,
+        algod_url=os.environ["ALGOD_URL"],          # e.g. https://mainnet-api.algonode.cloud
+        algod_token=os.environ.get("ALGOD_TOKEN", ""),
+        wait_rounds=4,
+    )
+"""
+
+from __future__ import annotations
+
+import base64
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+import algosdk
+from algosdk.v2client import algod
+
+from ap2_algorand.payment_method import X402_METHOD_NAME
+
+
+def settle(
+    payment_mandate: Any,
+    algod_url: str,
+    algod_token: str = "",
+    wait_rounds: int = 4,
+) -> Any:
+    """Submit an x402 Algorand payment and return an AP2 PaymentReceipt.
+
+    Reads the signed transaction from
+    ``payment_mandate.payment_mandate_contents.payment_response.details["value"]``,
+    submits it to the Algorand network, waits for on-chain confirmation, and
+    returns a ``PaymentReceipt`` with the transaction ID as the confirmation ID.
+
+    Args:
+        payment_mandate: An AP2 ``PaymentMandate`` instance.
+        algod_url: Algod REST endpoint (e.g. ``https://mainnet-api.algonode.cloud``).
+        algod_token: Algod API token. Empty string for public nodes.
+        wait_rounds: Maximum rounds to wait for confirmation (default 4).
+
+    Returns:
+        An AP2 ``PaymentReceipt`` (``payment_status`` is ``Success``).
+
+    Raises:
+        ValueError: If the payment_response is missing or has no x402 value.
+        algosdk.error.AlgodHTTPError: On algod submission failure.
+        Exception: If confirmation times out.
+    """
+    # ── 1. Extract signed transaction bytes ───────────────────────────────────
+    contents = payment_mandate.payment_mandate_contents
+    response = contents.payment_response
+
+    if response.method_name != X402_METHOD_NAME:
+        raise ValueError(
+            f"Expected payment method '{X402_METHOD_NAME}', "
+            f"got '{response.method_name}'"
+        )
+
+    x_payment: str | None = (response.details or {}).get("value")
+    if not x_payment:
+        raise ValueError(
+            "PaymentMandate.payment_response.details['value'] is missing. "
+            "The buyer agent must set this to the base64-encoded x402 SignedTransaction."
+        )
+
+    stxn_bytes = base64.b64decode(x_payment)
+
+    # ── 2. Submit to Algorand ─────────────────────────────────────────────────
+    algod_client = algod.AlgodClient(algod_token, algod_url)
+    txid: str = algod_client.send_raw_transaction(stxn_bytes)
+
+    # ── 3. Wait for on-chain confirmation ─────────────────────────────────────
+    algosdk.util.wait_for_confirmation(algod_client, txid, wait_rounds)
+
+    # ── 4. Build PaymentReceipt ───────────────────────────────────────────────
+    # Import AP2 types at call time so the package works without ap2 installed
+    # (e.g. for testing or non-AP2 use of the settle logic alone).
+    try:
+        from ap2.types.payment_receipt import PaymentReceipt, Success  # type: ignore[import]
+        from ap2.types.payment_request import PaymentCurrencyAmount    # type: ignore[import]
+    except ImportError as exc:
+        raise ImportError(
+            "ap2 package is required to build a PaymentReceipt. "
+            "Install it with: pip install ap2"
+        ) from exc
+
+    payment_id = uuid.uuid4().hex
+    payment_mandate_id = contents.payment_mandate_id
+    total_item = contents.payment_details_total
+
+    return PaymentReceipt(
+        payment_mandate_id=payment_mandate_id,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+        payment_id=payment_id,
+        amount=PaymentCurrencyAmount(
+            currency=total_item.amount.currency,
+            value=total_item.amount.value,
+        ),
+        payment_status=Success(
+            merchant_confirmation_id=txid,
+            psp_confirmation_id=txid,
+            network_confirmation_id=txid,
+        ),
+        payment_method_details={
+            "method_name": X402_METHOD_NAME,
+            "network": "algorand",
+            "txid": txid,
+        },
+    )
+
+
+def settle_raw(
+    x_payment: str,
+    algod_url: str,
+    algod_token: str = "",
+    wait_rounds: int = 4,
+) -> str:
+    """Submit a raw x402 payment header to Algorand and return the txid.
+
+    Lower-level alternative to :func:`settle` that works without AP2 types.
+    Useful for testing or non-AP2 contexts.
+
+    Args:
+        x_payment: Base64-encoded msgpack SignedTransaction (the X-PAYMENT header value).
+        algod_url: Algod REST endpoint.
+        algod_token: Algod API token. Empty string for public nodes.
+        wait_rounds: Maximum rounds to wait for confirmation.
+
+    Returns:
+        Algorand transaction ID string.
+    """
+    stxn_bytes = base64.b64decode(x_payment)
+    algod_client = algod.AlgodClient(algod_token, algod_url)
+    txid: str = algod_client.send_raw_transaction(stxn_bytes)
+    algosdk.util.wait_for_confirmation(algod_client, txid, wait_rounds)
+    return txid

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

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: ap2-algorand
+Version: 0.1.0
+Summary: Google AP2 × Algorand adapter — settle x402 payments from AP2 CartMandate/PaymentMandate
+License-Expression: MIT
+Keywords: algorand,x402,usdc,ap2,agent-payments,ai-agent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: py-algorand-sdk<3.0,>=2.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: ap2
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+
+# ap2-algorand
+
+**Google AP2 × Algorand x402 adapter** — settle AI agent payments on Algorand from an AP2 `PaymentMandate`.
+
+Bridges the [Google Agent Payments Protocol (AP2)](https://github.com/google-agentic-commerce/AP2) with non-custodial USDC payments on Algorand, enforced by AVM MandateContracts.
+
+## Install
+
+```bash
+pip install ap2-algorand
+```
+
+## Quick start
+
+### Buyer: advertise x402 Algorand in a CartMandate
+
+```python
+from ap2_algorand import AlgorandUsdcMethodData, X402_METHOD_NAME
+from ap2.types.payment_request import PaymentMethodData
+
+method = PaymentMethodData(
+    supported_methods=X402_METHOD_NAME,   # "https://www.x402.org/"
+    data=AlgorandUsdcMethodData(
+        mandate_app_id=3_498_113_854,     # agent's MandateContract app ID
+        asset_id=31_566_704,              # mainnet USDC ASA
+        network="mainnet",
+        x402_endpoint="https://api.example.com/weather",
+    ).model_dump(),
+)
+```
+
+### Buyer: parse payment args from a CartMandate
+
+```python
+from ap2_algorand import cart_to_payment_args
+
+args = cart_to_payment_args(cart_mandate)
+# args.mandate_app_id  → int
+# args.amount_micro_usdc → int  (e.g. 10_000 for $0.01 USDC)
+# args.asset_id        → int
+# args.x402_endpoint   → str
+```
+
+### Merchant: submit payment and get a PaymentReceipt
+
+```python
+import os
+from ap2_algorand import settle
+
+receipt = settle(
+    payment_mandate=payment_mandate,
+    algod_url="https://mainnet-api.algonode.cloud",
+)
+txid = receipt.payment_status.network_confirmation_id
+# txid == Algorand transaction ID (network IS the ledger)
+```
+
+### Lower-level: submit without AP2 types
+
+```python
+from ap2_algorand import settle_raw
+
+txid = settle_raw(
+    x_payment="<base64-msgpack-signed-tx>",
+    algod_url="https://mainnet-api.algonode.cloud",
+)
+```
+
+## How it maps to AP2
+
+| AP2 field | Algorand value |
+|---|---|
+| `payment_response.method_name` | `https://www.x402.org/` |
+| `payment_response.details["value"]` | `base64(msgpack(SignedTransaction))` |
+| `merchant_confirmation_id` | Algorand txid |
+| `psp_confirmation_id` | Algorand txid (AVM is the PSP) |
+| `network_confirmation_id` | Algorand txid (Algorand is the network) |
+| OTP challenge | skipped — AVM MandateContract enforces limits |
+
+## Dependencies
+
+- `py-algorand-sdk >= 2.0`
+- `pydantic >= 2.0`
+- `ap2` — optional, only needed for `settle()` return type (`PaymentReceipt`)
+
+## License
+
+MIT © Algo Wallet

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

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/ap2_algorand/__init__.py
+src/ap2_algorand/cart_adapter.py
+src/ap2_algorand/payment_method.py
+src/ap2_algorand/settle.py
+src/ap2_algorand.egg-info/PKG-INFO
+src/ap2_algorand.egg-info/SOURCES.txt
+src/ap2_algorand.egg-info/dependency_links.txt
+src/ap2_algorand.egg-info/requires.txt
+src/ap2_algorand.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,7 @@
+py-algorand-sdk<3.0,>=2.0
+pydantic>=2.0
+
+[ap2]
+
+[dev]
+pytest>=8.0

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

@@ -0,0 +1 @@
+ap2_algorand