Every rail. One call.

Pay anywhere.
Same safety.

Base, Solana, Stripe, Visa, x402, AWS AgentCore. One SDK call. One signed bundle. Every rail returns the same answer.

L6 verifierOristrust oracle
EVM L2 · native
Base
authoritative
SVM · native
Solana
anchor program
HTTP · native
x402
protocol-level
L2 · native
Arbitrum
mirror
Card · adapter
Stripe MPP
HTTP verifier
Runtime · adapter
AWS AgentCore
SDK middleware
Custody · adapter
Coinbase Agent
HTTP verifier
Card · pilot
Visa Tap
issuer pilot
L1 EVM
Ethereum
mirror
L2 OP
Optimism
mirror
L2 zkEVM
zkSync
mirror
Wallet · planned
PayPal
2026 Q3
Card · planned
Mastercard
2026 Q4
EVM L2 · native
Base
SVM · native
Solana
HTTP · native
x402
L2 · native
Arbitrum
Card · adapter
Stripe MPP
Runtime · adapter
AWS AgentCore
Custody · adapter
Coinbase Agent
Card · pilot
Visa Tap
How rails plug in

Three rails.
One bundle.

On chain rails check the bundle inside the transaction. Card and bank rails check it over HTTP. Runtimes embed it through the SDK.

01 / EVM L2 · native

Base

Authoritative

The authoritative chain, every registry, every anchor.

OrisAgentRegistry and OrisAnchorRegistry live on Base mainnet. Every other network mirrors state from here. The IComplianceVerifier reference implementation runs inline inside the settlement transaction.

VerifierIComplianceVerifier.sol
Anchor cadence24h + event-driven
Proof type0x01 Ed25519 · Faz A
Gas overhead~32k per verify
solidityverify path
function settle(bytes32 bundleId,
                bytes calldata sig)
    external {
    require(
      verifier.verifyAllow(
        bundleId, sig,
        IComplianceVerifier.Mode.Strict
      ),
      "oris: deny"
    );
    // settlement proceeds
    _transfer(msg.sender, to, amt);
}
02 / SVM · native

Solana

Native

Anchor program verifies inside the settlement instruction.

The Anchor program mirrors the Solidity ABI shape. Bundle hash + recursive sig are submitted as an instruction-level account; verification fails the entire transaction if the proof is stale or revoked.

Programoris_verifier.so
Anchor crateoris-anchor v0.4
CU cost~28k
Mirrorstate pulled hourly
rust · anchorinstruction
pub fn settle(
    ctx: Context<Settle>,
    bundle_id: [u8; 32],
    sig: [u8; 64],
) -> Result<()> {
    oris_verifier::verify_allow(
        &ctx.accounts.oris_root,
        bundle_id, sig,
    )?;
    // settlement proceeds
    token::transfer(...)?;
    Ok(())
}
03 / Card rail · adapter

Stripe MPP

Adapter

HTTP verifier-as-a-service, queried before authorization capture.

Stripe's Merchant-of-record agent flow calls the Oris verifier service over mTLS HTTP. If the verifier returns DENY, the authorization is voided before the cardholder ever sees a decline.

TransportHTTP/2 · mTLS
Median RTT18ms · EU-W
Modepre-authorization
Fallbackdeny-default 24h
typescriptoris-sdk
const verdict = await oris.verify({
  bundle:    bundleHash,
  signature: recursiveSig,
  rail:      "stripe.mpp",
  intent:    {
    amount_usd_e6: 14_820000,
    counterparty: "acct_1Nfg...",
  },
});

if (verdict.decision !== "ALLOW") {
  throw new OrisDeny(verdict.reason);
}
04 / Card rail · pilot

Visa Tap

Pilot · issuer-side

Bundle hash bound to the 3DS frictionless flag.

Issuers in the Visa Tap-to-Agent pilot use the Oris attestation as the friction-flag signal: if the bundle verifies, the transaction is exempt from step-up authentication. If revoked, the issuer can decline upstream of the merchant.

ChannelIssuer · pre-auth
Pilot regionEEA + UK
BIN typeagent-tier
Live issuers3 · Q2 2026
iso 8583 · de 55tag layout
// Issuer adds Oris pointer in DE 55
9F70  bundle_id_evm  (32 bytes)
9F71  recursive_sig  (64 bytes)
9F72  attest_expiry  (4 bytes)

// Issuer verifies inline before
// returning 3DS frictionless approval.
verifier.verify_allow(9F70, 9F71)
05 / Custodial · adapter

Coinbase Agent

Adapter

Required to exceed the daily spend ceiling.

Coinbase Agent wallets transact freely up to a daily ceiling. To exceed it, the agent must present an Oris bundle for each marginal transfer. Tier 1 revocations propagate into Coinbase's risk engine in real-time.

ChannelHTTP webhook
Triggerspend > ceiling
Revocation feedwebsocket stream
Liabilityshared · contracted
shell · requestverify
curl -X POST verify.useoris.xyz \
  -H "x-api-key: $ORIS_KEY" \
  -d '{
    "rail":    "coinbase.agent",
    "bundle":  "0x4ec821...d01",
    "sig":     "0xba27..."
  }'

// → 200 { decision: "ALLOW", ms: 4 }
06 / HTTP protocol · native

x402

Native

The 402 challenge resolves only with a valid Oris bundle.

Servers issuing HTTP 402 advertise an x-oris-required: true challenge. The client must respond with the bundle hash + recursive signature. The server verifies inline; the response includes the next nonce.

Headerx-oris-bundle
Cost fieldx-x402-cost-usd-e6
Nonce window30 seconds
Specx402 + OTCP draft
httpchallenge / response
// 402 challenge
HTTP/1.1 402 Payment Required
x-x402-cost-usd-e6: 148200
x-oris-required:    true
x-oris-nonce:       0xba27...

// client response
POST /resource
x-oris-bundle: 0x4ec821...d01
x-oris-sig:    0xc0ffee...
07 / Runtime · adapter

AWS AgentCore

Adapter

SDK middleware ships the bundle on every tool-call.

Drop-in middleware for the AgentCore Python and TypeScript SDKs. Every outbound HTTP call that hits a registered payment endpoint is automatically wrapped: bundle requested, attached, verified, logged.

RuntimePython 3.12 · TS 5.4
Wrap modetool-call interceptor
Latency add~6ms p99
Failure modetool-call denied
python · agentcoremiddleware
from oris.agentcore import trust

@trust(tenant="acme")
def main():
    agent = AgentCore.build(...)
    agent.run()
    # every payment tool-call is
    # intercepted, bundled, verified.
Pick your stack

Three SDKs.
One call.

Python, TypeScript, Rust. Old bundles still parse. Upgrading the SDK never breaks an integration you already shipped.

oris-py

pip install oris-sdk
# python · 3.10+
from oris import Client

c = Client(tenant="acme")
bundle = c.bundle(intent)
verdict = c.verify(bundle)

oris-sdk

npm i oris-sdk
// typescript
import { Oris } from "oris-sdk/protocol";

const oris = new Oris({ tenant });
const bundle = await oris.bundle(...);
const verdict = await oris.verify(bundle);

oris-rs

oris = "0.4"
// rust · 1.85+
use oris::Client;

let c = Client::new(&cfg);
let bundle = c.bundle(intent).await?;
let verdict = c.verify(&bundle).await?;
Before you launch a rail

Add Oris in two weeks.

200 lines on EVM and Solana. One HTTP endpoint everywhere else. We pair with your team and ship the integration together.

Talk to us → Read the docs