@wuwei-labs/srsly 2.0.0-beta.14 → 2.0.0-beta.16

package/README.md

@@ -8,842 +8,247 @@ A TypeScript SDK for building Solana instructions to interact with the SRSLY (Sp
 
 ## What This SDK Does
 
-The SRSLY SDK is an **instruction builder** that helps you create properly formatted Solana instructions for the SRSLY rental program. It handles:
+The SRSLY SDK is an **instruction builder** that helps you create properly formatted Solana instructions for fleet rentals. It handles:
 
-- ✅ Network-specific program addresses and configurations
-- ✅ Account derivation and validation
+- ✅ Account derivation and validation  
 - ✅ Instruction data encoding
 - ✅ Type-safe parameter handling
 
-## What You Need to Provide
-
-The SDK **does not** handle transaction creation, signing, or submission. You'll need to:
-
-- 🔧 Choose a transaction library (`@solana/web3.js` or `@solana/kit`)
-- 🔧 Connect to a Solana RPC endpoint
-- 🔧 Handle wallet integration (Phantom, Solflare, etc.)
-- 🔧 Build, sign, and send transactions
+**What you provide**: RPC connection, wallet integration, transaction handling.
 
 ## Installation
 
-### NPM
-
 ```bash
 npm install @wuwei-labs/srsly
-```
-
-### PNPM
-
-```bash
+# or
 pnpm add @wuwei-labs/srsly
-```
-
-### Yarn
-
-```bash
+# or  
 yarn add @wuwei-labs/srsly
 ```
 
 ## Quick Start
 
 ```typescript
-import { 
-  createContract, 
-  setConfig 
-} from '@wuwei-labs/srsly';
-
-import {
-  createDefaultSolanaRpc,
-  createTransaction, 
-  appendInstructions,
-  signAndSendTransaction,
-  pipe
-} from '@solana/kit';
-
-// Step 1: Set up RPC connection
-const rpc = createDefaultSolanaRpc('https://api.atlasnet.solana.com');
-
-// Step 2: Get wallet from browser extension (Phantom, Solflare, etc.)
-// Assumes you've already connected to the user's wallet
-const wallet = window.solana; // or your wallet adapter
+import { createContract, setConfig } from '@wuwei-labs/srsly';
+import { Connection, Transaction } from '@solana/web3.js';
 
-// Step 3: Configure SDK to use atlasnet program addresses
-setConfig({ network: 'atlasnet' });
+// 1. Configure SDK for your network
+setConfig({ programs: 'atlasnet' });
 
-// Step 4: Build the instruction using SRSLY SDK
-const contractInstruction = await createContract({
-  owner: wallet.publicKey, // Wallet's public key
+// 2. Build instruction
+const instruction = await createContract({
+  owner: walletPublicKey,
   fleet: fleetAddress,
   ownerProfile: profileAddress,
-  rate: 1000000, // Rate in ATLAS tokens
-  durationMin: 86400, // 1 day in seconds
-  durationMax: 604800, // 1 week in seconds
-  paymentsFreq: 'daily',
-  ownerKeyIndex: 0
+  rate: 1000000, // ATLAS tokens
+  durationMin: 86400, // 1 day
+  durationMax: 604800, // 1 week
+  paymentsFreq: 'daily'
 });
 
-// Step 5: Build transaction and send (using your preferred method)
-const transaction = pipe(
-  createTransaction({ version: 0 }),
-  tx => appendInstructions([contractInstruction], tx)
-);
-
-// Sign and send using wallet extension
-const signature = await signAndSendTransaction(rpc, transaction, wallet);
-console.log('Transaction signature:', signature);
-```
-
-**Alternative with @solana/web3.js:**
-
-```typescript
-import { Connection, Transaction } from '@solana/web3.js';
-
+// 3. Build and send transaction
 const connection = new Connection('https://api.atlasnet.solana.com');
-const transaction = new Transaction().add(contractInstruction);
-
-// Sign and send with wallet extension
-const signature = await window.solana.signAndSendTransaction(transaction);
+const transaction = new Transaction().add(instruction);
+const signature = await wallet.signAndSendTransaction(transaction);
 ```
 
-> **Note**: The SRSLY SDK only creates instructions. You're responsible for:
-> - Setting up RPC connections
-> - Managing wallet connections (Phantom, Solflare, etc.)
-> - Building, signing, and sending transactions
-> - Handling transaction confirmation and errors
-
----
-
-## SDK Features
-
-The following examples show how to use the SRSLY SDK to build instructions. Add these instructions to transactions using your preferred Solana library (`@solana/web3.js` or `@solana/kit`).
+## Core Features
 
 ### Contract Management
 
-Create and manage rental contracts for Star Atlas fleets:
-
 ```typescript
 import { createContract, closeContract } from '@wuwei-labs/srsly';
 
-// Create a new rental contract with network configuration
+// Create rental contract
 const createIx = await createContract({
   owner: wallet,
   fleet: fleetAddress,
   ownerProfile: profileAddress,
-  rate: 5000000, // Rate in ATLAS tokens
-  durationMin: 86400, // Minimum 1 day
-  durationMax: 2592000, // Maximum 30 days
-  paymentsFreq: 'daily',
-  ownerKeyIndex: 0
-}).set({ network: 'mainnet' }); // Use mainnet configuration
-
-// Close an existing contract using atlasnet programs (direct await)
+  rate: 5000000,
+  durationMin: 86400,
+  durationMax: 2592000,
+  paymentsFreq: 'daily'
+});
+
+// Close contract
 const closeIx = await closeContract({
   owner: wallet,
   fleet: fleetAddress,
-  contract: contractAddress,
-  faction: 'mud' // or faction number: 1, 2, 3
+  contract: contractAddress
 });
 ```
 
 ### Rental Operations
 
-Handle rental lifecycle operations with automatic token conversion:
-
 ```typescript
-import { 
-  acceptRental, 
-  cancelRental, 
-  closeRental, 
-  resetRental,
-  ATLAS_TO_STARDUST
-} from '@wuwei-labs/srsly';
+import { acceptRental, cancelRental, closeRental } from '@wuwei-labs/srsly';
 
-// Accept a rental offer on atlasnet (rate-based with automatic conversion)
+// Accept rental offer
 const acceptIx = await acceptRental({
   borrower: borrowerWallet,
   borrowerProfile: borrowerProfileAddress,
-  borrowerFaction: 'oni', // or faction number: 1=mud, 2=oni, 3=ustur
+  borrowerFaction: 'mud', // or 1, 2, 3
   fleet: fleetAddress,
   contract: contractAddress,
-  rate: 100, // ATLAS tokens (not per second, just ATLAS)
+  rate: 100, // ATLAS per day
   duration: 86400 // 1 day in seconds
-  // amount = rate * duration * ATLAS_TO_STARDUST automatically calculated
-}).set({ network: 'atlasnet' });
+});
 
-// Cancel an active rental using atlasnet programs (direct await)
+// Cancel active rental
 const cancelIx = await cancelRental({
   borrower: borrowerWallet,
   contract: contractAddress,
   rentalState: rentalStateAddress
 });
 
-// Close a completed rental on mainnet
+// Close completed rental
 const closeIx = await closeRental({
   borrower: borrowerWallet,
   contract: contractAddress,
   rentalState: rentalStateAddress,
   ownerTokenAccount: ownerTokenAccountAddress
-}).set({ network: 'mainnet' });
-
-// Reset rental state with custom configuration
-const resetIx = await resetRental({
-  fleet: fleetAddress,
-  contract: contractAddress,
-  rentalState: rentalStateAddress,
-  faction: 'mud',
-  ownerProfile: ownerProfileAddress
-}).set({ 
-  network: 'mainnet',
-  sageProgramAddress: 'custom...',
-  gameId: 'custom...'
-});
-```
-
-### Account State Management
-
-Fetch and decode account states using network-specific functions:
-
-```typescript
-import { getCachedNetworkModule } from '@wuwei-labs/srsly';
-
-// Get network-specific account functions (programs to atlasnet)
-const accountsModule = await getCachedNetworkModule('accounts');
-const { fetchContractState, fetchRentalState } = accountsModule;
-
-// Or specify network explicitly
-const mainnetAccountsModule = await getCachedNetworkModule('accounts', 'mainnet');
-
-// Fetch contract state
-const contractState = await fetchContractState(rpc, contractPublicKey);
-console.log('Contract rate:', contractState.rate.toString());
-console.log('Duration range:', contractState.durationMin.toString(), '-', contractState.durationMax.toString());
-
-// Fetch rental state
-const rentalState = await fetchRentalState(rpc, rentalPublicKey);
-console.log('Rental status:', rentalState.status);
-console.log('Start time:', new Date(rentalState.startTime.toNumber() * 1000));
-```
-
-### Error Handling
-
-The SDK provides custom error types for better debugging:
-
-```typescript
-import { SrslyError } from '@wuwei-labs/srsly';
-
-try {
-  const instruction = await createContract(params);
-  // Add to transaction and send...
-} catch (error) {
-  if (error instanceof SrslyError) {
-    console.error('SRSLY SDK Error:', error.message, error.code);
-  } else {
-    console.error('Other Error:', error);
-  }
-}
-```
-
-### Token Conversion
-
-The SDK includes automatic ATLAS to stardust conversion for rental operations:
-
-```typescript
-import { ATLAS_TO_STARDUST } from '@wuwei-labs/srsly';
-
-// ATLAS_TO_STARDUST = 100_000_000 (1 ATLAS = 100 million stardust)
-console.log('Conversion rate:', ATLAS_TO_STARDUST);
-
-// When using acceptRental with rate and duration:
-// Final amount = rate * duration * ATLAS_TO_STARDUST
-// Example: 100 ATLAS * 86400 seconds * 100_000_000 = 864,000,000,000,000 stardust
-```
-
-## Program Information
-
-- **Program ID**: `SRSLY1fq9TJqCk1gNSE7VZL2bztvTn9wm4VR8u8jMKT`
-- **Network**: Solana Mainnet or Atlasnet
-- **Built with**: Anchor Framework
-
-## Payment Structure
-
-The SRSLY program implements a comprehensive payment system with escrow deposits, periodic payments, fees, and refunds. Understanding this structure is crucial for integrating rental functionality.
-
-### Overview
-
-```text
-Rental Lifecycle:
-1. Escrow Deposit (Full Payment Upfront)
-2. Periodic Payments (Based on Payment Frequency)
-3. Fee Collection (Platform + Referral Fees)
-4. Owner Payments (After Fee Deduction)
-5. Refunds (For Early Cancellation)
-```
-
-### 1. Escrow Deposit
-
-When a borrower accepts a rental, they deposit the **full rental amount upfront** into an escrow account:
-
-```typescript
-// Example: 1000 ATLAS for 10 days = 10,000 ATLAS total
-const acceptIx = await acceptRental({
-  borrower: wallet,
-  borrowerProfile: profileAddress,
-  borrowerFaction: 'mud',
-  fleet: fleetAddress,
-  contract: contractAddress,
-  rate: 1000, // ATLAS tokens per day
-  duration: 864000, // 10 days in seconds
-  referralTokenAccount: referrerAddress // Optional referral
-});
-// Total escrowed: 1000 * 10 * 100,000,000 = 1,000,000,000,000 stardust
-```
-
-**Key Points:**
-
-- Full payment calculated as: `rate × duration × ATLAS_TO_STARDUST`
-- Funds are held in a rental-specific escrow account
-- Escrow is controlled by the rental state PDA
-- No payments to owner until periodic execution
-- **Minimum enforcement**: 24 hours from start time (if no payments) or last payment time
-
-### 2. Periodic Payments
-
-The system creates an automated thread that executes payments based on the contract's payment frequency:
-
-```typescript
-// Contract with daily payments
-const contractIx = await createContract({
-  owner: wallet,
-  fleet: fleetAddress,
-  ownerProfile: profileAddress,
-  rate: 1000,
-  durationMin: 86400, // 1 day minimum
-  durationMax: 2592000, // 30 days maximum  
-  paymentsFreq: 'daily' // Payments every 24 hours
-});
-```
-
-**Payment Schedule:**
-
-- **Daily**: Payments execute daily at 00:00 UTC (not every 24 hours from creation)
-- **Weekly**: Payments execute weekly at specific day/time
-- **Monthly**: Payments execute monthly at specific day/time
-
-**Pro-rata Calculation:**
-
-Each payment is calculated based on elapsed time since the last payment:
-
-```text
-payment_amount = (elapsed_time / frequency_seconds) × rate × ATLAS_TO_STARDUST
-```
-
-### 3. Fee Structure
-
-Each payment is subject to a **10% platform fee** with optional **10% referral sharing**:
-
-```typescript
-// Constants from the program
-const SERVICE_FEE_BPS = 1000;    // 10% platform fee
-const REFERRAL_BPS = 1000;       // 10% of total fee to referral
-const BASE_BPS = 10000;          // 100% in basis points
-```
-
-**Fee Calculation:**
-
-```typescript
-// For each payment amount
-const totalFee = paymentAmount * SERVICE_FEE_BPS / BASE_BPS; // 10% of payment
-const referralFee = totalFee * REFERRAL_BPS / BASE_BPS;     // 10% of total fee
-const platformFee = totalFee - referralFee;                 // 90% of total fee
-const ownerPayment = paymentAmount - totalFee;              // 90% of payment
-```
-
-**Example Payment Breakdown:**
-
-```text
-Payment Amount: 1000 ATLAS
-├── Total Fee (10%): 100 ATLAS
-│   ├── Referral Fee (10% of total fee): 10 ATLAS → Referrer
-│   └── Platform Fee (90% of total fee): 90 ATLAS → Platform
-└── Owner Payment (90%): 900 ATLAS → Fleet Owner
-```
-
-### 4. Payment Distribution
-
-Each periodic payment is distributed in this order:
-
-1. **Referral Payment** (if referrer exists and ≠ system_program::ID)
-   - Amount: `total_fee × REFERRAL_BPS ÷ BASE_BPS`
-   - Destination: Referrer's token account
-
-2. **Platform Fee Payment**
-   - Amount: `total_fee - referral_payment`
-   - Destination: Platform fee account
-
-3. **Owner Payment**
-   - Amount: `payment_amount - total_fee`
-   - Destination: Fleet owner's token account
-
-**Code Example:**
-
-```typescript
-// Accept rental with referral
-const acceptIx = await acceptRental({
-  borrower: wallet,
-  borrowerProfile: profileAddress,
-  borrowerFaction: 'mud',
-  fleet: fleetAddress,
-  contract: contractAddress,
-  rate: 1000,
-  duration: 86400,
-  referralTokenAccount: referrerTokenAccount // 10% of fees
-});
-```
-
-### 5. Refund Mechanism
-
-Refunds occur when rentals are cancelled early or when contracts are closed. **Important: All rentals enforce a minimum 24-hour active period from either the start time (if no payments made) or the last payment time.**
-
-**Early Cancellation:**
-
-```typescript
-const cancelIx = await cancelRental({
-  borrower: wallet,
-  contract: contractAddress,
-  rentalState: rentalStateAddress
 });
 ```
 
-**Refund Scenarios:**
-
-- **Before First Payment**: Rental remains active for 24 hours from start time, pro-rata refund for remaining time
-- **After Payment(s) Made**: Rental remains active for 24 hours from last payment time, pro-rata refund for remaining time
-- **Contract Closure**: Any remaining escrow returned to borrower
-
-### 6. Payment Timeline Example
-
-**Scenario**: 10-day rental with daily payments, 1000 ATLAS/day rate
-
-```text
-Day 0: Rental Accepted
-├── Escrow: 10,000 ATLAS deposited
-├── Thread: Created for daily execution at 00:00 UTC
-├── Fleet: Transferred to borrower
-└── Minimum 24-hour commitment begins (from start time)
-
-00:00 UTC Next Day: First Payment
-├── Amount: 1,000 ATLAS from escrow
-├── Total Fee (10%): 100 ATLAS
-│   ├── Referrer: 10 ATLAS (10% of total fee)
-│   └── Platform: 90 ATLAS (90% of total fee)
-├── Owner: 900 ATLAS (90% of payment)
-├── Escrow: 9,000 ATLAS remaining
-└── New 24-hour minimum period begins (from payment time)
-
-Daily at 00:00 UTC: Subsequent Payments
-├── Same distribution pattern
-├── Escrow decreases by 1,000 ATLAS each day
-└── Each payment resets 24-hour minimum period
-
-Final Day at 00:00 UTC: Final Payment & Cleanup
-├── Final payment processed
-├── Thread: Automatically closed
-├── Rental State: Closed, lamports to borrower
-└── Fleet: Returned to owner or contract
-
-Early Cancellation Examples:
-
-Scenario A - Cancel before first payment (Day 0 at 6 PM):
-├── Cancelled 6 hours after start
-├── Rental extends until 24 hours from start time (Day 1 at start time)
-├── Pro-rata refund calculated from Day 1 extended end onwards
-└── Borrower receives refund for Days 1-10
-
-Scenario B - Cancel after payments made (Day 3 at 6 PM):
-├── Cancelled 18 hours after Day 3 payment (00:00 UTC)
-├── Rental extends until 24 hours from last payment (Day 4 at 00:00 UTC)
-├── Pro-rata refund calculated from Day 4 onwards
-└── Borrower receives refund for Days 4-10
-```
-
-### 7. Edge Cases
-
-**Insufficient Escrow Balance:**
-
-- Payment amount is limited to available escrow balance
-- Remaining balance distributed proportionally
-
-**Early Termination:**
-
-- **Cancellation Notice**: Must have more than one payment period remaining to cancel
-- **Minimum Period Enforcement**:
-  - Before first payment: Active for 24 hours from start time
-  - After payment(s): Active for 24 hours from last payment time
-- **Pro-rata Refund**: Refund calculated from the enforced minimum end time
-- Fleet returned to owner when minimum period expires
-- Payment thread continues until minimum period ends
-
-**Contract Closure:**
-
-- Final payment processed if rental active
-- All remaining resources cleaned up
-- Fleet rental capability removed
-
-## Payment Frequencies
-
-The SDK supports multiple payment frequencies:
-
-- `daily` - Daily payments at 00:00 UTC
-- `weekly` - Weekly payments at specific day/time  
-- `monthly` - Monthly payments at specific day/time
-
-
 ## Network Configuration
 
-The SDK supports both Solana mainnet and atlasnet with different IDL artifacts and default program addresses for each network. The configuration system has two main purposes:
-
-### What `setConfig` Does:
-
-**1. Network Selection (IDL/Module Loading):**
-- ✅ Selects which IDL artifacts to use (`mainnet` vs `atlasnet`)
-- ✅ Loads appropriate codama-generated instruction builders
-- ✅ Determines default program addresses for the network
-
-**2. Program Address Selection:**
-- ✅ Select predefined program address sets (mainnet, atlasnet, holosim)
-- ✅ Override specific program addresses (SRSLY, SAGE, Profile Faction)
-- ✅ Override game IDs and other network constants
-- ✅ Mix and match programs across networks if needed
-
-**What it does NOT do:**
-- ❌ Configure RPC endpoints
-- ❌ Handle wallet connections
-- ❌ Manage transactions
-
-### Global Configuration (Recommended)
+The SDK supports multiple network configurations:
 
-Set default configuration once for all SDK operations:
+### Global Configuration
 
 ```typescript
-import { setConfig, getConfig, createContract } from '@wuwei-labs/srsly';
+import { setConfig, getConfig, clearConfig } from '@wuwei-labs/srsly';
 
-// Example 1: Use mainnet IDL with default mainnet program addresses
-setConfig({ 
-  network: 'mainnet'
-});
-
-// Example 2: Use atlasnet IDL with default atlasnet program addresses
-setConfig({ 
-  network: 'atlasnet'
-});
-
-// Example 3: Use atlasnet IDL with holosim program addresses
-setConfig({ 
-  network: 'atlasnet',
-  programs: 'holosim'
-});
+// Use mainnet programs
+setConfig({ programs: 'mainnet' });
 
-// Example 4: Use atlasnet IDL with holosim programs but custom SAGE
-setConfig({ 
-  network: 'atlasnet',
-  programs: 'holosim',
-  sageProgramAddress: 'custom-sage-program-id...'
-});
+// Use atlasnet programs (default)
+setConfig({ programs: 'atlasnet' });
 
-// Example 5: Use mainnet IDL with atlasnet program addresses
-setConfig({ 
-  network: 'mainnet',
-  programs: 'atlasnet'
-});
+// Use holosim test programs
+setConfig({ programs: 'holosim' });
 
-// Example 6: Custom overrides only
+// Custom configuration
 setConfig({ 
-  network: 'atlasnet',
-  srslyProgramAddress: 'custom-srsly-program-id...',
-  sageProgramAddress: 'custom-sage-program-id...',
+  programs: 'mainnet',
+  sageProgramAddress: 'custom-sage-program...',
   gameId: 'custom-game-id...'
 });
 
-// Check current configuration
+// Check current config
 console.log(getConfig());
 
-// All operations now use configured settings
-const ix1 = await createContract(params); // Uses configured SRSLY program
-const ix2 = await acceptRental(params);   // Uses configured SAGE program
+// Reset to defaults
+clearConfig();
 ```
 
 ### Per-Instruction Configuration
 
-Override global program address configuration for specific instructions using the fluent `.set()` interface:
-
 ```typescript
-import { createContract, acceptRental } from '@wuwei-labs/srsly';
-
-// Assume global config is set to mainnet program addresses
-setConfig({ network: 'mainnet' });
-
-// Use global mainnet program addresses
-const mainnetIx = await createContract(params);
-
-// Override to use atlasnet program addresses for this specific instruction
-const atlasnetIx = await createContract(params).set({ network: 'atlasnet' });
+// Override global config for specific instructions
+const ix = await createContract(params).set({ programs: 'mainnet' });
 
-// Override specific program addresses while keeping global network
-const customIx = await createContract(params).set({ 
-  sageProgramAddress: 'custom-sage-program-id...',
-  gameId: 'custom-game-id...'
-  // network: 'mainnet' inherited from global config
-});
-```
-
-### Configuration Options
-
-All SDK functions support these usage patterns:
-
-**Direct await (uses global config or atlasnet fallback):**
-
-```typescript
-// Uses global program addresses if set, otherwise atlasnet programs
-await createContract(params);
-await acceptRental(params);
+// Chain multiple configurations
+const ix2 = await acceptRental(params)
+  .set({ programs: 'holosim' })
+  .set({ gameId: 'custom-game-id...' });
 ```
 
-**Global configuration functions:**
+## Payment System
 
-- `setConfig({ network: 'mainnet', gameId: '...' })` - Set global program addresses
-- `getConfig()` - Get current global configuration
-- `clearConfig()` - Reset to atlasnet programs
+SRSLY implements an escrow-based payment system:
 
-**Per-instruction overrides with `.set()` method:**
-
-- `.set({ network: 'mainnet' })` - Override to mainnet program addresses
-- `.set({ sageProgramAddress: '...' })` - Override specific program address only  
-- `.set({ network: 'mainnet', sageProgramAddress: '...' })` - Multiple overrides
-
-**Chainable configurations:**
-
-```typescript
-// Chain multiple configurations (later ones override earlier ones)
-await createContract(params)
-  .set({ network: 'atlasnet' })
-  .set({ sageProgramAddress: 'override...' });
-
-// Examples with global config
-setConfig({ network: 'mainnet' });
-await createContract(params); // Uses mainnet program addresses
-await acceptRental(params).set({ network: 'atlasnet' }); // Override to atlasnet programs  
-await closeContract(params).set({ gameId: 'custom...' }); // Custom gameId, mainnet programs
-```
-
-### Available Configuration Options
+1. **Escrow**: Borrower deposits full rental amount upfront
+2. **Periodic Payments**: Automated payments based on frequency (daily/weekly/monthly) 
+3. **Fees**: 10% platform fee, optional 10% referral sharing
+4. **Refunds**: Pro-rata refunds for early cancellation (24-hour minimum)
 
 ```typescript
-interface ConfigOptions {
-  network?: 'mainnet' | 'atlasnet';            // Which IDL artifacts to use
-  programs?: 'mainnet' | 'atlasnet' | 'holosim'; // Which program address set to use
-  srslyProgramAddress?: string;                // Override SRSLY program address
-  sageProgramAddress?: string;                 // Override SAGE program address
-  profileFactionProgramAddress?: string;       // Override Profile Faction program address  
-  gameId?: string;                            // Override SAGE game ID
-}
+// Payment calculation
+const rate = 1000; // ATLAS per day
+const duration = 86400; // 1 day in seconds
+const totalAmount = rate * duration * ATLAS_TO_STARDUST; // in stardust
 ```
 
-**Available Program Address Sets:**
+## Available Networks
 
 ```typescript
-// mainnet
-{
-  srslyProgram: 'SRSLY1fq9TJqCk1gNSE7VZL2bztvTn9wm4VR8u8jMKT',
-  sageProgram: 'SAGE2HAwep459SNq61LHvjxPk4pLPEJLoMETef7f7EE',
-  profileFactionProgram: 'pFACSRuobDmvfMKq1bAzwj27t6d2GJhSCHb1VcfnRmq',
-  gameId: 'GAMEzqJehF8yAnKiTARUuhZMvLvkZVAsCVri5vSfemLr'
-}
-
-// atlasnet (default) - values currently empty, to be filled
-{
-  srslyProgram: 'SRSLY1fq9TJqCk1gNSE7VZL2bztvTn9wm4VR8u8jMKT',
-  sageProgram: '',
-  profileFactionProgram: '', 
-  gameId: ''
-}
-
-// holosim
-{
-  srslyProgram: 'SRSLY1fq9TJqCk1gNSE7VZL2bztvTn9wm4VR8u8jMKT',
-  sageProgram: 'SAgeTraQfBMdvGVDJYoEvjnbq5szW7RJPi6obDTDQUF',
-  profileFactionProgram: 'PprofUW1pURCnMW2si88GWPXEEK3Bvh9Tksy8WtnoYJ', 
-  gameId: 'GAMEC7U7cqmFFaRow33j1LwuV8u4YhAS1mJ5Dqjnar2k'
-}
-```
-
-**Priority Order:**
-1. Individual overrides (highest priority)
-2. programs configuration
-3. Network default (if programs not specified)
-
-**Key Concepts:**
-
-- **Network** = Which IDL/codama artifacts to load (affects instruction structure)
-- **programs** = Which predefined program address set to use (mainnet, atlasnet, holosim)
-- **Program Overrides** = Override individual program addresses (highest priority)
-- **Default Behavior** = If programs not specified, uses network's program addresses
-- **Flexibility** = Mix any IDL with any program set, plus individual overrides
-
-### Network-Specific Constants
-
-The SDK automatically resolves network-specific constants:
-
-```typescript
-import { 
-  getSageProgramAddress, 
-  getProfileFactionProgramAddress, 
-  getSageGameId 
-} from '@wuwei-labs/srsly';
-
-// Get constants for atlasnet (default)
-const sageProgram = await getSageProgramAddress();
-const gameId = await getSageGameId();
-
-// Get constants for specific network
-const mainnetSageProgram = await getSageProgramAddress({ network: 'mainnet' });
-const mainnetGameId = await getSageGameId({ network: 'mainnet' });
-```
-
-## IDL and Types
-
-### Network-Specific IDLs
-
-The SDK provides network-specific IDLs since program configurations differ between networks:
-
-```typescript
-// Mainnet IDL
-import mainnetIdl from '@wuwei-labs/srsly/idl/mainnet';
-
-// Devnet IDL  
-import atlasnetIdl from '@wuwei-labs/srsly/idl/atlasnet';
-
-// Use with Anchor
-import { Program } from '@coral-xyz/anchor';
-const program = new Program(mainnetIdl, provider);
+// Program address sets
+const networks = {
+  mainnet: {
+    sageProgram: 'SAGE2HAwep459SNq61LHvjxPk4pLPEJLoMETef7f7EE',
+    gameId: 'GAMEzqJehF8yAnKiTARUuhZMvLvkZVAsCVri5vSfemLr'
+  },
+  atlasnet: {
+    sageProgram: 'SAgeTraQfBMdvGVDJYoEvjnbq5szW7RJPi6obDTDQUF',
+    gameId: 'GAMEC7U7cqmFFaRow33j1LwuV8u4YhAS1mJ5Dqjnar2k'
+  },
+  holosim: { 
+    sageProgram: 'SAgeTraQfBMdvGVDJYoEvjnbq5szW7RJPi6obDTDQUF',
+    gameId: 'GAMEC7U7cqmFFaRow33j1LwuV8u4YhAS1mJ5Dqjnar2k'
+  }
+};
 ```
 
-### Network-Specific Types
-
-Import TypeScript types that match your target network:
+## Types and Constants
 
 ```typescript
 import type { 
-  ContractState,
-  RentalState,
-  PaymentFrequency,
-  ClockData,
-  ThreadResponse,
-  ConfigOptions
+  ContractState, 
+  RentalState, 
+  ConfigOptions,
+  PaymentFrequency 
 } from '@wuwei-labs/srsly';
 
-// Import network-specific Anchor types
-import type { Srsly as SrslyMainnet } from '@wuwei-labs/srsly/types/mainnet';
-import type { Srsly as SrslyDevnet } from '@wuwei-labs/srsly/types/atlasnet';
-```
-
-## Constants and Utilities
-
-### Available Constants
-
-```typescript
 import { 
   ATLAS_TO_STARDUST,
-  STARBASE_SEED,
-  STARBASE_PLAYER_SEED,
-  SAGE_PLAYER_PROFILE_SEED,
-  PROFILE_FACTION_SEED,
-  FACTION_MAPPING,
-  FACTION_SPECIFIC_CSS
+  FACTION_MAPPING 
 } from '@wuwei-labs/srsly';
 
-// Token conversion
+// Conversion rate: 1 ATLAS = 100,000,000 stardust
 console.log(ATLAS_TO_STARDUST); // 100_000_000
 
 // Faction mappings
 console.log(FACTION_MAPPING[1]); // 'mud'
-console.log(FACTION_MAPPING[2]); // 'oni'  
+console.log(FACTION_MAPPING[2]); // 'oni' 
 console.log(FACTION_MAPPING[3]); // 'ustur'
 ```
 
-### Profile Derivation
+## IDL and Program Information
 
 ```typescript
-import { 
-  deriveProfileFaction,
-  deriveSagePlayerProfile,
-  deriveStarbase,
-  deriveStarbasePlayer,
-  deriveGameAccounts
-} from '@wuwei-labs/srsly';
-
-// Derive individual accounts with network configuration
-const profileFaction = await deriveProfileFaction(profile, { network: 'mainnet' });
-const starbase = await deriveStarbase('mud', gameId, { network: 'mainnet' });
-
-// Derive all game accounts at once
-const gameAccounts = await deriveGameAccounts(
-  profile, 
-  'mud', 
-  gameId, 
-  0, // starbaseSeqId
-  { network: 'mainnet' }
-);
+// Access program IDLs
+import mainnetIdl from '@wuwei-labs/srsly/idl/mainnet';
+import atlasnetIdl from '@wuwei-labs/srsly/idl/atlasnet';
 ```
 
-## Webpack Compatibility
-
-The SRSLY SDK is fully compatible with webpack bundlers. The package includes both CommonJS and ESM builds:
-
-- **CommonJS**: `./dist/cjs/index.cjs` (default for Node.js and webpack)
-- **ESM**: `./dist/esm/index.js` (for modern ES modules)
-- **Types**: `./dist/types/index.d.ts` (TypeScript definitions)
-
-### Webpack Configuration
-
-For optimal webpack compatibility, the SDK includes:
-
-- `sideEffects: false` for better tree-shaking
-- Proper CommonJS exports with `.cjs` extensions for webpack bundling
-- ES module interoperability
-- Correct module resolution for mixed ESM/CommonJS environments
-
-No special webpack configuration is required. The SDK will work out-of-the-box with most webpack setups.
-
-**Note**: As of version 2.0.0-beta.9, the CommonJS build uses `.cjs` file extensions to ensure proper module resolution in environments where the package.json contains `"type": "module"`.
-
-### Testing Webpack Compatibility
-
-```bash
-# Test local CommonJS exports (fast)
-npm run test:webpack
+## Error Handling
 
-# Test actual npm package installation (comprehensive)
-npm run test:npm-install
-
-# Test actual pnpm package installation with webpack bundling
-npm run test:pnpm-install
+```typescript
+import { SrslyError } from '@wuwei-labs/srsly';
 
-# Test both package managers
-npm run test:package-managers
+try {
+  const instruction = await createContract(params);
+  // Add to transaction and send...
+} catch (error) {
+  if (error instanceof SrslyError) {
+    console.error('SRSLY SDK Error:', error.message, error.code);
+  } else {
+    console.error('Other Error:', error);
+  }
+}
 ```
 
-These commands test different aspects:
-- `test:webpack`: Tests local CommonJS exports that webpack uses
-- `test:npm-install`: Installs the actual published package via npm and tests functionality
-- `test:pnpm-install`: Installs via pnpm and includes a real webpack bundling test
-- `test:package-managers`: Runs both npm and pnpm tests
+## Package Structure
 
-## Documentation
+The SDK provides optimized builds for different environments:
 
-- **TypeDoc Documentation**: [API Reference](https://wuwei-labs.github.io/srsly/)
+- **CommonJS**: `./dist/cjs/` (Node.js, webpack)
+- **ESM**: `./dist/esm/` (Modern ES modules)
+- **Types**: `./dist/types/` (TypeScript definitions)
+- **Shared**: `./dist/shared/codama/` (Optimized codama exports)
 
-## Related Projects
+## Links
 
-- **Star Atlas**: The metaverse gaming ecosystem
-- **Solana**: The blockchain platform powering SRSLY
-- **Anchor**: The framework used to build the SRSLY program
+- **NPM Package**: [@wuwei-labs/srsly](https://www.npmjs.com/package/@wuwei-labs/srsly)
+- **TypeDoc Documentation**: [API Reference](https://wuwei-labs.github.io/srsly/)