Oris Python SDK

Compliant payment infrastructure + Oris Trust Protocol verifier client for autonomous AI agents. Oris provides wallets, identity verification (KYA), spending controls, compliance monitoring, and the L8 verifier client (oris.protocol) for any agentic payment network that consumes Oris compliance bundles.

Installation

pip install oris-sdk

Oris Trust Protocol (oris.protocol, v0.2.0)

For any network that consumes Oris compliance bundles (Base, x402, Coinbase Agent, Stripe MPP, Visa Tap, AWS AgentCore — Base shipped in v1, others v2):

from oris.protocol import OrisProtocol

p = OrisProtocol(network="base-sepolia")

# 1. Fetch the live verifier pubkey
pubkey = p.verifier.get_pubkey()

# 2. Build a 112-byte tx_intent preimage
tx_intent_hex = p.adapter.encode_tx_intent_hex(
    counterparty="0x" + "11" * 20,
    amount_usd_e6=1_000_000,
    stablecoin="USDC",
    category="0x" + "00" * 32,
    nonce="0x" + "ab" * 32,
    expires_at=9_999_999_999,
)

# 3. Verify a compliance bundle against the live verifier
verdict = p.verifier.verify(
    bundle_bytes_hex=bundle_hex,
    tx_intent_hex=tx_intent_hex,
    signer_pubkey_hex=agent_pubkey_hex,
)

# 4. Independently verify the verdict's Ed25519 signature offline
ok = p.verifier.verify_response_signature(verdict, pubkey.pubkey_hex)

The legacy OrisClient / Agent surface is unchanged in 0.2.0; the oris.protocol namespace is purely additive.

For local source installation:

git clone https://github.com/fluxaventures/useoris.git
cd useoris
pip install -e .

Quick Start

Send your first autonomous, compliant payment in under 10 lines of code.

from oris import OrisClient

# 1. Initialize client
client = OrisClient(api_key="YOUR_API_KEY", private_key="YOUR_PRIVATE_KEY")

# 2. Register and verify agent
agent = client.agents.register(name="Researcher-01", description="Data procurement agent")
client.agents.verify(agent.id)

# 3. Create an ERC-4337 Smart Account
wallet = client.wallets.create(agent_id=agent.id, chain="polygon")

# 4. Set a spending policy
client.policies.create(
    agent_id=agent.id,
    daily_limit_usd=100.0,
    allowed_contracts=["0xDatasetProviderAddress"]
)

# 5. Execute autonomous payment
tx = client.payments.send(
    agent_id=agent.id,
    to_address="0xDatasetProviderAddress",
    amount=1.0,
    chain="polygon",
    token="POL"
)

print(f"Transaction settled. Hash: {tx.transaction_hash}")

Authentication

Oris enforces Ed25519 request signing with strict replay protection (30s window). The SDK handles all cryptographic signing and rate-limit retries automatically.

Provide your credentials directly or via environment variables (ORIS_API_KEY, ORIS_PRIVATE_KEY).

Agent Lifecycle

The Oris infrastructure requires agents to follow a strict compliance lifecycle before accessing on-chain liquidity:

1. Registration: Agent identity is recorded.
2. KYA (Know Your Agent) Verification: Agent undergoes AML and risk screening.
3. Wallet Creation: Counterfactual deployment of an ERC-4337 smart account.
4. Policy Attachment: Hardcoded on-chain and off-chain spending limits.
5. Execution: Gas-abstracted, sponsored transaction routing.

Core Methods Reference

Agents

client.agents.register(name: str, description: str) -> Agent
client.agents.verify(agent_id: str) -> bool
client.agents.get_profile(agent_id: str) -> AgentProfile

Wallets

client.wallets.create(agent_id: str, chain: str) -> Wallet
client.wallets.get_balance(wallet_id: str) -> Balance
client.wallets.get_wallets(agent_id: str) -> list[Wallet]

Policies

client.policies.create(agent_id: str, **kwargs) -> Policy
client.policies.simulate_payment(agent_id: str, amount: float) -> SimulationResult

Payments

client.payments.send(agent_id: str, to_address: str, amount: float, chain: str, token: str) -> PaymentResult
client.payments.get_payment(payment_id: str) -> PaymentStatus

Async Support

Every synchronous method has an asynchronous counterpart for high-concurrency environments.

import asyncio
from oris import AsyncOrisClient

async def main():
    client = AsyncOrisClient(api_key="...", private_key="...")
    tx = await client.payments.asend(...)
    print(tx.transaction_hash)

asyncio.run(main())

Error Handling

The SDK provides a structured exception hierarchy.

from oris.exceptions import OrisAuthError, OrisRateLimitError, OrisComplianceError

try:
    client.payments.send(...)
except OrisComplianceError as e:
    print(f"Transaction blocked by Veris compliance engine: {e}")
except OrisRateLimitError as e:
    print(f"Rate limit exceeded. Retry after {e.retry_after}s")

Supported Chains

Oris currently manages RPC routing and bundler infrastructure for the following networks: