feat: pivot to escrow contract for Stellar Checkout

Replace token streaming contract with escrow functionality:
- create_escrow, release, refund, get_escrow functions
- Escrow struct with Active/Released/Refunded status
- Timeout-based refund protection
- Tests for create, release, refund, and timeout scenarios
- Remove stream, math modules

Author: O.Omokaro

CLAUDE.md

@@ -1,63 +1,41 @@
-# OrbitStream Contracts
+# Stellar Checkout Contracts
 
 ## Project
-Soroban smart contract for OrbitStream — a token streaming/payroll platform on Stellar blockchain.
+Soroban smart contract for Stellar Checkout — escrow functionality for dispute-prone payments.
 
 ## Stack
-- Rust
-- Soroban SDK
+- Rust (edition 2021)
+- Soroban SDK v21
 - Stellar Testnet / Mainnet
 
 ## What This Contract Does
-Handles salary payroll streams on Stellar. Employers create streams to employees,
-employees claim accrued tokens anytime (pull-based).
-
-## Core Data Structure
-- Stream: id, employer, employee, token, rate_per_second, deposited, withdrawn,
-  start_time, end_time, pause_time, paused_duration, status
+Manages escrowed payments for marketplace and freelance transactions. Buyers deposit funds
+that are locked until released by seller or refunded after timeout.
 
 ## Contract Functions
-### Employer
-- create_stream(employer, employee, token, rate_per_second, start_time, end_time, deposit)
-- top_up(stream_id, amount)
-- pause_stream(stream_id)
-- resume_stream(stream_id)
-- cancel_stream(stream_id)
-- update_rate(stream_id, new_rate)
-
-### Employee
-- claim(stream_id)
-- claim_partial(stream_id, amount)
-
-### Read
-- get_stream(stream_id)
-- get_claimable(stream_id)
-- get_streams_by_employer(employer)
-- get_streams_by_employee(employee)
+- `create_escrow(buyer, seller, token, amount, timeout_seconds) -> escrow_id` — lock funds
+- `release(escrow_id)` — seller releases funds to themselves
+- `refund(escrow_id)` — buyer claims refund after timeout
+- `get_escrow(escrow_id) -> Escrow` — read escrow details
 
-## Claimable Math
-elapsed = min(now, end_time) - start_time - paused_duration
-accrued = elapsed * rate_per_second
-claimable = min(accrued, deposited) - withdrawn
+## Data Structure
+Escrow: id, buyer, seller, token, amount, status (Active/Released/Refunded), created_at, timeout_at
 
 ## File Structure
 src/
-  lib.rs        - contract entry point
-  stream.rs     - Stream struct + StreamStatus enum
+  lib.rs        - contract entry point (StellarCheckoutEscrow)
+  escrow.rs     - Escrow struct + EscrowStatus enum
   storage.rs    - read/write contract storage
-  math.rs       - claimable calculation
-  events.rs     - all event definitions
+  events.rs     - EscrowCreated, EscrowReleased, EscrowRefunded
   errors.rs     - custom error types
 tests/
-  test_create.rs
-  test_claim.rs
-  test_pause_resume.rs
-  test_cancel.rs
+  test_create_escrow.rs
+  test_release.rs
+  test_refund.rs
 
 ## Key Rules
-- No business logic outside of contract (no user profiles, no analytics)
-- All state changes must emit events
-- Protect against overflow/underflow everywhere
-- Only employer can pause/cancel/top_up/update_rate
-- Only employee can claim
-- Token is USDC on Stellar by default, but contract is multi-token
+- Only buyer can create escrow and request refund
+- Only seller can release funds
+- Refund only valid after timeout
+- All state changes emit events
+- Protect against invalid amounts and timeouts

src/errors.rs

@@ -3,16 +3,10 @@ use soroban_sdk::contracterror;
 #[contracterror]
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
 pub enum ContractError {
-    StreamNotFound = 1,
+    EscrowNotFound = 1,
     Unauthorized = 2,
-    InsufficientBalance = 3,
-    InvalidStream = 4,
-    OverflowError = 5,
-    UnderflowError = 6,
-    InvalidTimeRange = 7,
-    StreamAlreadyPaused = 8,
-    StreamNotPaused = 9,
-    StreamCancelled = 10,
-    InvalidAmount = 11,
-    InvalidRate = 12,
+    EscrowAlreadySettled = 3,
+    TimeoutNotReached = 4,
+    InvalidAmount = 5,
+    InvalidTimeout = 6,
 }

src/escrow.rs

@@ -0,0 +1,22 @@
+use soroban_sdk::{contracttype, Address};
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[contracttype]
+pub enum EscrowStatus {
+    Active = 0,
+    Released = 1,
+    Refunded = 2,
+}
+
+#[derive(Clone)]
+#[contracttype]
+pub struct Escrow {
+    pub id: u64,
+    pub buyer: Address,
+    pub seller: Address,
+    pub token: Address,
+    pub amount: u128,
+    pub status: EscrowStatus,
+    pub created_at: u64,
+    pub timeout_at: u64,
+}

src/events.rs

@@ -1,82 +1,40 @@
-use soroban_sdk::{contracttype, Address, Env, Symbol, Val};
+use soroban_sdk::{contracttype, Address, Env, Symbol};
 
 #[contracttype]
-pub struct StreamCreatedEvent {
-    pub stream_id: u64,
-    pub employer: Address,
-    pub employee: Address,
+pub struct EscrowCreatedEvent {
+    pub escrow_id: u64,
+    pub buyer: Address,
+    pub seller: Address,
     pub token: Address,
-    pub rate_per_second: u128,
-    pub deposited: u128,
-    pub start_time: u64,
-    pub end_time: u64,
-}
-
-#[contracttype]
-pub struct StreamTopUpEvent {
-    pub stream_id: u64,
     pub amount: u128,
+    pub timeout_at: u64,
 }
 
 #[contracttype]
-pub struct StreamClaimedEvent {
-    pub stream_id: u64,
-    pub employee: Address,
+pub struct EscrowReleasedEvent {
+    pub escrow_id: u64,
+    pub seller: Address,
     pub amount: u128,
 }
 
 #[contracttype]
-pub struct StreamPausedEvent {
-    pub stream_id: u64,
-}
-
-#[contracttype]
-pub struct StreamResumedEvent {
-    pub stream_id: u64,
-}
-
-#[contracttype]
-pub struct StreamCancelledEvent {
-    pub stream_id: u64,
-}
-
-#[contracttype]
-pub struct StreamRateUpdatedEvent {
-    pub stream_id: u64,
-    pub new_rate: u128,
-}
-
-pub fn emit_stream_created(env: &Env, event: StreamCreatedEvent) {
-    env.events()
-        .publish((Symbol::new(env, "stream_created"),), event);
-}
-
-pub fn emit_stream_top_up(env: &Env, event: StreamTopUpEvent) {
-    env.events()
-        .publish((Symbol::new(env, "stream_top_up"),), event);
-}
-
-pub fn emit_stream_claimed(env: &Env, event: StreamClaimedEvent) {
-    env.events()
-        .publish((Symbol::new(env, "stream_claimed"),), event);
-}
-
-pub fn emit_stream_paused(env: &Env, event: StreamPausedEvent) {
-    env.events()
-        .publish((Symbol::new(env, "stream_paused"),), event);
+pub struct EscrowRefundedEvent {
+    pub escrow_id: u64,
+    pub buyer: Address,
+    pub amount: u128,
 }
 
-pub fn emit_stream_resumed(env: &Env, event: StreamResumedEvent) {
+pub fn emit_escrow_created(env: &Env, event: EscrowCreatedEvent) {
     env.events()
-        .publish((Symbol::new(env, "stream_resumed"),), event);
+        .publish((Symbol::new(env, "escrow_created"),), event);
 }
 
-pub fn emit_stream_cancelled(env: &Env, event: StreamCancelledEvent) {
+pub fn emit_escrow_released(env: &Env, event: EscrowReleasedEvent) {
     env.events()
-        .publish((Symbol::new(env, "stream_cancelled"),), event);
+        .publish((Symbol::new(env, "escrow_released"),), event);
 }
 
-pub fn emit_stream_rate_updated(env: &Env, event: StreamRateUpdatedEvent) {
+pub fn emit_escrow_refunded(env: &Env, event: EscrowRefundedEvent) {
     env.events()
-        .publish((Symbol::new(env, "stream_rate_updated"),), event);
+        .publish((Symbol::new(env, "escrow_refunded"),), event);
 }