@opendatalabs/vana-sdk 0.1.0-alpha.e64ec83 → 0.1.0-alpha.e72c89b

package/README.md

@@ -1,33 +1,23 @@
 # Vana SDK
 
-The Vana SDK is a comprehensive TypeScript library for building applications on the Vana Network. It provides simple, powerful APIs for gasless data permissions, file management, and secure data portability.
+> **⚠️ ALPHA SOFTWARE - EXPERIMENTAL USE ONLY**
+>
+> This SDK is in early alpha development and is **NOT SUITABLE FOR PRODUCTION USE**.
+> Features may change without notice, and data loss or unexpected behavior may occur.
+> Use at your own risk and avoid using with mainnet assets or critical operations.
 
-[![npm version](https://img.shields.io/npm/v/vana-sdk)](https://www.npmjs.com/package/vana-sdk)
+A TypeScript SDK for building data-driven applications on the Vana Network. Enable users to grant gasless permissions, manage encrypted data, and interact with privacy-preserving infrastructure.
+
+[![npm version](https://img.shields.io/npm/v/@opendatalabs/vana-sdk)](https://www.npmjs.com/package/@opendatalabs/vana-sdk)
 [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue)](https://www.typescriptlang.org/)
 [![License: ISC](https://img.shields.io/badge/License-ISC-green.svg)](https://opensource.org/licenses/ISC)
 
-[Documentation](https://vana-com.github.io/vana-sdk) • [Examples](#examples) • [API Reference](https://vana-com.github.io/vana-sdk)
-
-## Why Vana SDK?
-
-- **🔐 Gasless Permissions**: EIP-712 based permission system with zero gas fees for users
-- **📁 Data Management**: Query, upload, and manage encrypted user data files
-- **🔄 Flexible Relaying**: Callback-based relay system supporting any gasless transaction infrastructure
-- **📊 Schema Validation**: Built-in JSON Schema and SQLite schema validation with AJV
-- **🔧 Type-Safe**: Full TypeScript support with comprehensive type definitions
-- **🎯 Production Ready**: Battle-tested with comprehensive error handling and retry mechanisms
+[API Documentation](https://vana-com.github.io/vana-sdk) • [Examples](#examples) • [Configuration](#configuration)
 
 ## Installation
 
 ```bash
-# npm
-npm install vana-sdk
-
-# yarn
-yarn add vana-sdk
-
-# pnpm
-pnpm add vana-sdk
+npm install @opendatalabs/vana-sdk
 ```
 
 **Peer Dependencies:**
@@ -38,13 +28,22 @@ npm install viem@^2.31.7
 
 ## Quick Start
 
-### Basic Setup
+The Vana SDK provides optimized builds for different environments:
+
+| Build          | Use Case                          | Crypto Implementation              | Configuration     |
+| -------------- | --------------------------------- | ---------------------------------- | ----------------- |
+| **`/browser`** | Browser apps (React, Vue)         | Pure JavaScript (@noble/secp256k1) | **Zero config** ✓ |
+| **`/node`**    | Server-side (Node.js, API routes) | Native bindings (secp256k1)        | Zero config ✓     |
+
+### Browser Applications
+
+The browser build uses pure JavaScript cryptography and requires **no special configuration**:
 
 ```typescript
-import { Vana } from "vana-sdk";
+// Browser build - works out of the box with any bundler
+import { Vana, mokshaTestnet } from "@opendatalabs/vana-sdk/browser";
 import { createWalletClient, http } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-import { mokshaTestnet } from "vana-sdk";
 
 // Create wallet client
 const account = privateKeyToAccount("0x...");
@@ -54,104 +53,140 @@ const walletClient = createWalletClient({
   transport: http("https://rpc.moksha.vana.org"),
 });
 
-// Initialize Vana SDK
-const vana = new Vana({
+// Initialize SDK
+const vana = Vana({
   walletClient,
-  // Optional: configure gasless relayer
   relayerUrl: "https://relayer.moksha.vana.org",
 });
 ```
 
-### Grant Data Permission (Gasless)
+### Server-side Applications (Node.js)
+
+The Node.js build uses native secp256k1 bindings for optimal performance:
 
 ```typescript
-// Grant permission for an AI application to access user data
+// For server-side applications (Next.js API routes, Express)
+import { Vana, mokshaTestnet } from "@opendatalabs/vana-sdk/node";
+import { createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// Create wallet client
+const account = privateKeyToAccount("0x...");
+const walletClient = createWalletClient({
+  account,
+  chain: mokshaTestnet,
+  transport: http("https://rpc.moksha.vana.org"),
+});
+
+// Initialize SDK
+const vana = Vana({
+  walletClient,
+  relayerUrl: "https://relayer.moksha.vana.org",
+});
+
+// Grant gasless permission
 const txHash = await vana.permissions.grant({
-  to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36", // Application address
+  grantee: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
   operation: "llm_inference",
   parameters: {
-    prompt: "Analyze my browsing data for insights",
+    prompt: "Analyze my data for insights",
     maxTokens: 1000,
-    files: [12, 15, 28], // Specific file IDs
-    model: "gpt-4",
   },
-  expiresAt: Math.floor(Date.now() / 1000) + 24 * 60 * 60, // 24 hours
+  expiresAt: Math.floor(Date.now() / 1000) + 86400, // 24 hours
 });
+```
+
+## Core Features
 
-console.log("Permission granted:", txHash);
+### Gasless Permissions
+
+Users can grant data access permissions without paying gas fees through EIP-712 signatures and relay infrastructure.
+
+```typescript
+// Grant permission with custom parameters
+await vana.permissions.grant({
+  grantee: applicationAddress,
+  operation: "data_analysis",
+  parameters: {
+    analysisType: "sentiment",
+    files: [12, 15, 28],
+    model: "gpt-4",
+  },
+});
 ```
 
-### Query User Data Files
+### Encrypted Data Management
+
+Upload, query, and manage encrypted user data files with built-in schema validation.
 
 ```typescript
-// Get all files owned by a user
+// Query user files
 const files = await vana.data.getUserFiles({
-  user: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+  owner: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
 });
 
-files.forEach((file) => {
-  console.log(`File ${file.id}: ${file.url}`);
-  console.log(`Schema: ${file.schemaId}, Added: ${file.addedAtBlock}`);
+// Upload encrypted file with decryption permissions
+const result = await vana.data.upload({
+  content: "Sensitive user data",
+  filename: "user-data.json",
+  schemaId: 123,
+  permissions: [
+    {
+      account: "0xServerAddress...", // Who can decrypt
+      publicKey: "0x04ServerKey...", // Their public key
+    },
+  ],
 });
 ```
 
-### Upload Encrypted File
+### Flexible Storage
+
+Abstract storage layer supporting IPFS, Google Drive, and custom providers.
 
 ```typescript
-// Generate encryption key from wallet
-const encryptionKey = await generateEncryptionKey(walletClient);
+// For browser applications
+import { StorageManager, PinataStorage } from "@opendatalabs/vana-sdk/browser";
+// OR for server-side applications
+// import { StorageManager, PinataStorage } from "@opendatalabs/vana-sdk/node";
 
-// Encrypt user data
-const userData = new Blob([
-  JSON.stringify({
-    browsing_history: [{ url: "https://example.com", timestamp: Date.now() }],
+const storageManager = new StorageManager();
+storageManager.register(
+  "ipfs",
+  new PinataStorage({
+    apiKey: process.env.PINATA_API_KEY,
+    secretKey: process.env.PINATA_SECRET_KEY,
   }),
-]);
-
-const encryptedData = await encryptUserData(userData, encryptionKey);
-
-// Upload to IPFS and register on-chain
-const result = await vana.data.uploadEncryptedFile({
-  data: encryptedData,
-  schemaId: 123, // JSON schema for browsing data
-  filename: "browsing-data.json",
-});
-
-console.log("File uploaded:", result.fileId, result.url);
+);
 ```
 
 ## Architecture
 
-The Vana SDK follows a resource-oriented architecture with five main controllers:
-
-### Core Controllers
+The SDK provides four main controllers:
 
-| Controller             | Purpose                                 | Key Methods                                                       |
-| ---------------------- | --------------------------------------- | ----------------------------------------------------------------- |
-| **`vana.permissions`** | Gasless permission grants & revocations | `grant()`, `revoke()`, `getUserPermissions()`                     |
-| **`vana.data`**        | Data file management & encryption       | `getUserFiles()`, `uploadEncryptedFile()`, `validateDataSchema()` |
-| **`vana.server`**      | Trusted server management               | `trustServer()`, `untrustServer()`, `processWithTrustedServer()`  |
-| **`vana.protocol`**    | Low-level contract access               | `getContract()`, `getAvailableContracts()`                        |
+| Controller    | Purpose                        | Key Methods                                                       |
+| ------------- | ------------------------------ | ----------------------------------------------------------------- |
+| `permissions` | Gasless permission management  | `grant()`, `revoke()`, `getUserPermissions()`                     |
+| `data`        | File management and validation | `getUserFiles()`, `uploadEncryptedFile()`, `validateDataSchema()` |
+| `server`      | Trusted server operations      | `trustServer()`, `processWithTrustedServer()`                     |
+| `protocol`    | Contract interaction           | `getContract()`, `getAvailableContracts()`                        |
 
-### Configuration Options
+## Configuration
 
 ```typescript
-const vana = new Vana({
-  // Required: Wallet client for signing
+const vana = Vana({
   walletClient,
 
-  // Optional: Gasless transaction relay
-  relayerUrl: "https://custom-relayer.com",
+  // Gasless transaction relay
+  relayerUrl: "https://relayer.moksha.vana.org",
 
-  // Optional: Custom callback-based relaying
+  // Custom relay callbacks
   relayerCallbacks: {
     submitPermissionGrant: async (typedData, signature) => {
-      // Custom relay implementation
       return await customRelayer.submit(typedData, signature);
     },
   },
 
-  // Optional: Storage configuration
+  // Storage configuration
   storageManager: new StorageManager({
     defaultProvider: "ipfs",
     providers: {
@@ -159,63 +194,92 @@ const vana = new Vana({
     },
   }),
 
-  // Optional: Subgraph for efficient data queries
+  // Subgraph for efficient queries
   subgraphUrl: "https://api.thegraph.com/subgraphs/name/vana/moksha",
 });
 ```
 
-## Core Concepts
-
-### Gasless Permissions
+## Error Handling
 
-The Vana SDK enables applications to request data access permissions without users paying gas fees:
+The SDK provides specific error types for different failure scenarios:
 
 ```typescript
-// Complete gasless permission flow
-const permission = await vana.permissions.grant({
-  to: applicationAddress,
-  operation: "data_analysis",
-  parameters: {
-    // Structured parameters for the operation
-    analysisType: "sentiment",
-    outputFormat: "json",
-    maxDataPoints: 1000,
-  },
-});
+import {
+  RelayerError,
+  UserRejectedRequestError,
+  SchemaValidationError,
+  NetworkError,
+} from "@opendatalabs/vana-sdk/browser";
+// OR for server-side applications
+// } from "@opendatalabs/vana-sdk/node";
 
-// The SDK handles:
-// 1. Parameter serialization & IPFS storage
-// 2. EIP-712 typed data creation
-// 3. User signature via wallet
-// 4. Relayer submission & gas payment
-// 5. On-chain permission registration
+try {
+  await vana.permissions.grant(params);
+} catch (error) {
+  if (error instanceof UserRejectedRequestError) {
+    // User cancelled transaction
+  } else if (error instanceof RelayerError) {
+    // Relayer service error
+  } else if (error instanceof SchemaValidationError) {
+    // Schema validation failed
+  }
+}
 ```
 
-### Data File Management
+## Supported Networks
+
+| Network            | Chain ID | RPC URL                       |
+| ------------------ | -------- | ----------------------------- |
+| **Vana Mainnet**   | `1480`   | `https://rpc.vana.org`        |
+| **Moksha Testnet** | `14800`  | `https://rpc.moksha.vana.org` |
 
-Query and manage encrypted user data files using the subgraph for efficiency:
+## Examples
+
+### Complete Data Sharing Flow
 
 ```typescript
-// Efficiently query user files (no contract scanning)
-const files = await vana.data.getUserFiles({
-  user: userAddress,
-  // Optional: override subgraph URL
-  subgraphUrl: "https://custom-subgraph.com/graphql",
-});
+import { Vana } from "@opendatalabs/vana-sdk/browser";
+// OR for server-side applications
+// } from "@opendatalabs/vana-sdk/node";
 
-// Files are automatically deduplicated by ID
-// Latest timestamp wins for duplicate file IDs
-console.log(`Found ${files.length} unique files`);
+async function shareDataWithServer() {
+  const vana = Vana({ walletClient });
+
+  // Step 1: Upload encrypted file with decryption permissions
+  const uploadResult = await vana.data.upload({
+    content: { data: "sensitive medical records" },
+    filename: "health-data.json",
+    schemaId: 123,
+    permissions: [
+      {
+        // Grant decryption access to the AI server
+        account: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+        publicKey: "0x04abc...", // Server's public key for encryption
+      },
+    ],
+  });
+
+  // Step 2: Grant operation permissions for what the server can do
+  const permissionResult = await vana.permissions.grant({
+    grantee: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+    fileIds: [BigInt(uploadResult.fileId)],
+    operation: "medical_analysis",
+    parameters: {
+      model: "medical-ai-v2",
+      analysisType: "comprehensive",
+    },
+  });
+
+  return { uploadResult, permissionResult };
+}
 ```
 
 ### Schema Validation
 
-Built-in support for validating data schemas and user data:
-
 ```typescript
-// Validate a data schema against Vana meta-schema
+// Define data schema
 const schema = {
-  name: "Instagram Export",
+  name: "Social Media Export",
   version: "1.0.0",
   dialect: "json",
   schema: {
@@ -224,345 +288,130 @@ const schema = {
       posts: { type: "array" },
       profile: { type: "object" },
     },
+    required: ["profile"],
   },
 };
 
+// Validate schema
 vana.data.validateDataSchema(schema);
 
-// Validate user data against the schema
-const userData = { posts: [], profile: { username: "alice" } };
+// Validate user data
+const userData = {
+  profile: { username: "alice" },
+  posts: [],
+};
 vana.data.validateDataAgainstSchema(userData, schema);
 ```
 
-### Flexible Relay System
-
-Configure gasless transactions using callbacks instead of fixed HTTP APIs:
-
-```typescript
-const vana = new Vana({
-  walletClient,
-  relayerCallbacks: {
-    // Custom permission grant relaying
-    submitPermissionGrant: async (typedData, signature) => {
-      const response = await fetch("/api/relay/grant", {
-        method: "POST",
-        body: JSON.stringify({ typedData, signature }),
-      });
-      const result = await response.json();
-      return result.transactionHash;
-    },
-
-    // Custom revocation relaying
-    submitPermissionRevoke: async (typedData, signature) => {
-      return await myCustomRelayer.revoke(typedData, signature);
-    },
-  },
-});
-```
-
 ## API Reference
 
-### Permissions Controller
+### Permissions
 
 ```typescript
-// Grant permission (gasless)
+// Grant operation permission
 await vana.permissions.grant({
-  to: Address,                    // Application address
-  operation: string,              // Operation type
-  parameters: object,             // Operation parameters
-  expiresAt?: number             // Optional expiration timestamp
-}): Promise<Hash>
-
-// Revoke permission (gasless)
+  grantee: Address,
+  fileIds: bigint[],
+  operation: string,
+  parameters: object,
+  expiresAt?: number
+}): Promise<PermissionGrantResult>
+
+// Revoke permission
 await vana.permissions.revoke({
-  grantId: string,               // Grant ID to revoke
-  nonce?: bigint                 // Optional nonce override
+  grantId: string
 }): Promise<Hash>
 
-// Query user permissions
+// Get user permissions
 await vana.permissions.getUserPermissions({
-  user: Address,                 // User address
-  subgraphUrl?: string          // Optional subgraph override
+  owner: Address
 }): Promise<GrantedPermission[]>
-
-// Trust a server
-await vana.permissions.trustServer({
-  serverAddress: Address,        // Server's address
-  serverUrl: string             // Server's URL
-}): Promise<Hash>
 ```
 
-### Data Controller
+### Data
 
 ```typescript
 // Get user files
 await vana.data.getUserFiles({
-  user: Address,                 // File owner address
-  subgraphUrl?: string          // Optional subgraph override
+  owner: Address
 }): Promise<UserFile[]>
 
-// Upload encrypted file
-await vana.data.uploadEncryptedFile({
-  data: Blob,                   // Encrypted file data
-  schemaId?: number,            // Optional schema ID
-  filename?: string             // Optional filename
-}): Promise<UploadEncryptedFileResult>
-
-// Validate data schema
-vana.data.validateDataSchema(
-  schema: unknown             // Schema to validate
-): asserts schema is DataSchema
+// Upload data with automatic encryption
+await vana.data.upload({
+  content: string | Blob | Buffer,
+  filename?: string,
+  schemaId?: number,
+  permissions?: Array<{
+    account: Address,     // Who can decrypt
+    publicKey: string     // Their public key
+  }>,
+  encrypt?: boolean       // Default: true
+}): Promise<UploadResult>
+
+// Validate schema
+vana.data.validateDataSchema(schema: unknown): void
 
 // Validate data against schema
-vana.data.validateDataAgainstSchema(
-  data: unknown,                // Data to validate
-  schema: DataSchema        // Data schema
-): void
-
-// Fetch and validate remote schema
-await vana.data.fetchAndValidateSchema(
-  url: string                   // Schema URL
-): Promise<DataSchema>
-```
-
-### Server Controller
-
-```typescript
-// Process data with trusted server
-await vana.server.processWithTrustedServer({
-  serverUrl: string,            // Trusted server URL
-  operation: string,            // Operation to perform
-  parameters: object            // Operation parameters
-}): Promise<any>
-
-// Check server trust status
-await vana.server.isServerTrusted({
-  user: Address,                // User address
-  serverAddress: Address        // Server address
-}): Promise<boolean>
-```
-
-### Protocol Controller
-
-```typescript
-// Get contract information
-vana.protocol.getContract(
-  contractName: VanaContract    // Contract name
-): ContractInfo
-
-// List available contracts
-vana.protocol.getAvailableContracts(): VanaContract[]
-
-// Get contract addresses for chain
-vana.protocol.getChainContracts(
-  chainId: number              // Chain ID
-): Record<VanaContract, Address>
-```
-
-## Storage Integration
-
-The SDK includes a powerful storage abstraction supporting multiple providers:
-
-### IPFS Storage
-
-```typescript
-import { StorageManager, PinataStorage } from "vana-sdk";
-
-const storageManager = new StorageManager();
-
-// Configure Pinata IPFS
-const pinataStorage = new PinataStorage({
-  apiKey: process.env.PINATA_API_KEY,
-  secretKey: process.env.PINATA_SECRET_KEY,
-  gatewayUrl: "https://gateway.pinata.cloud/ipfs",
-});
-
-storageManager.register("ipfs", pinataStorage, true); // Default provider
-
-// Upload file
-const result = await storageManager.upload(encryptedBlob, "encrypted-data.bin");
-```
-
-### Google Drive Storage
-
-```typescript
-import { StorageManager, GoogleDriveStorage } from "vana-sdk";
-
-const googleDriveStorage = new GoogleDriveStorage({
-  accessToken: process.env.GOOGLE_DRIVE_ACCESS_TOKEN,
-  refreshToken: process.env.GOOGLE_DRIVE_REFRESH_TOKEN,
-  clientId: process.env.GOOGLE_DRIVE_CLIENT_ID,
-  clientSecret: process.env.GOOGLE_DRIVE_CLIENT_SECRET,
-});
-
-storageManager.register("google-drive", googleDriveStorage);
-```
-
-### Custom Storage Provider
-
-```typescript
-class CustomStorage implements StorageProvider {
-  async upload(file: Blob, filename?: string): Promise<StorageUploadResult> {
-    // Custom upload logic
-    return { url: "custom://uploaded-file", size: file.size };
-  }
-
-  async download(url: string): Promise<Blob> {
-    // Custom download logic
-  }
-
-  // ... other required methods
-}
-
-storageManager.register("custom", new CustomStorage());
-```
-
-## Error Handling
-
-The SDK provides comprehensive error handling with specific error types:
-
-```typescript
-import {
-  RelayerError,
-  UserRejectedRequestError,
-  SchemaValidationError,
-  InvalidConfigurationError,
-  NetworkError,
-} from "vana-sdk";
-
-try {
-  await vana.permissions.grant(params);
-} catch (error) {
-  if (error instanceof UserRejectedRequestError) {
-    // User rejected the signature request
-    console.log("User cancelled transaction");
-  } else if (error instanceof RelayerError) {
-    // Relayer service error
-    console.log(`Relayer error (${error.statusCode}): ${error.message}`);
-  } else if (error instanceof SchemaValidationError) {
-    // Schema validation failed
-    console.log(`Schema error: ${error.message}`);
-  } else if (error instanceof NetworkError) {
-    // Network connectivity issue
-    console.log(`Network error: ${error.message}`);
-  } else {
-    // Unexpected error
-    console.error("Unexpected error:", error);
-  }
-}
+vana.data.validateDataAgainstSchema(data: unknown, schema: DataSchema): void
 ```
 
-## Supported Networks
+## Documentation
 
-| Network            | Chain ID | RPC URL                       | Explorer                                         |
-| ------------------ | -------- | ----------------------------- | ------------------------------------------------ |
-| **Vana Mainnet**   | `1480`   | `https://rpc.vana.org`        | [vanascan.io](https://vanascan.io)               |
-| **Moksha Testnet** | `14800`  | `https://rpc.moksha.vana.org` | [moksha.vanascan.io](https://moksha.vanascan.io) |
+- [API Documentation](https://vana-com.github.io/vana-sdk) - Complete TypeDoc API reference
+- [Getting Started](https://vana-com.github.io/vana-sdk/getting-started) - Step-by-step setup guide
+- [Architecture](https://vana-com.github.io/vana-sdk/architecture) - SDK design and patterns
+- [Configuration](https://vana-com.github.io/vana-sdk/configuration) - All configuration options
+- [Security](https://vana-com.github.io/vana-sdk/security) - Best practices and security
 
-### Adding Networks to Wallet
+## Support
 
-**Moksha Testnet:**
+- **Documentation**: [vana-com.github.io/vana-sdk](https://vana-com.github.io/vana-sdk)
+- **Issues**: [GitHub Issues](https://github.com/vana-com/vana-sdk/issues)
+- **Discord**: [Join our community](https://discord.gg/vanabuilders)
 
-```
-Network Name: Vana Moksha Testnet
-RPC URL: https://rpc.moksha.vana.org
-Chain ID: 14800
-Currency Symbol: VANA
-Block Explorer: https://moksha.vanascan.io
-```
+## Generated Code
 
-## Examples
+The SDK includes automatically generated code from various sources to provide type-safe interfaces. All generated files are located in `src/generated/` and should **never be edited manually**.
 
-### Complete Permission Flow
+### Code Generation Scripts
 
-```typescript
-import { Vana, generateEncryptionKey, encryptUserData } from "vana-sdk";
+| Script                       | Purpose                                | Generated Files             |
+| ---------------------------- | -------------------------------------- | --------------------------- |
+| `npm run fetch-abis`         | Smart contract ABIs from blockchain    | `src/generated/abi/*.ts`    |
+| `npm run fetch-server-types` | Personal server API types from OpenAPI | `src/generated/server/*.ts` |
+| `npm run codegen:subgraph`   | GraphQL types from subgraph schema     | `src/generated/subgraph.ts` |
 
-async function completePermissionFlow() {
-  // 1. Initialize SDK
-  const vana = new Vana({ walletClient });
+### Network-Specific Generation
 
-  // 2. Encrypt user data
-  const encryptionKey = await generateEncryptionKey(walletClient);
-  const userData = new Blob([JSON.stringify({ data: "sensitive info" })]);
-  const encryptedData = await encryptUserData(userData, encryptionKey);
+Some generation scripts support different networks:
 
-  // 3. Upload encrypted file
-  const uploadResult = await vana.data.uploadEncryptedFile({
-    data: encryptedData,
-    schemaId: 123,
-    filename: "user-data.json",
-  });
-
-  // 4. Grant permission to access the file
-  const permissionTx = await vana.permissions.grant({
-    to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
-    operation: "ai_training",
-    parameters: {
-      files: [uploadResult.fileId],
-      model: "llm-v1",
-      maxTokens: 500,
-    },
-  });
+```bash
+# Generate subgraph types for different networks
+npm run codegen:subgraph:moksha   # Moksha testnet (default)
+npm run codegen:subgraph:mainnet  # Vana mainnet
 
-  console.log("Permission granted:", permissionTx);
-}
+# Generate ABIs for different networks
+npm run fetch-abis moksha         # Moksha testnet (default)
+npm run fetch-abis mainnet        # Vana mainnet
 ```
 
-### Schema Validation Example
+### Development Workflow
 
-```typescript
-// Define a data schema
-const instagramSchema = {
-  name: "Instagram Export",
-  version: "1.0.0",
-  description: "User's Instagram profile and posts data",
-  dialect: "json",
-  schema: {
-    type: "object",
-    properties: {
-      profile: {
-        type: "object",
-        properties: {
-          username: { type: "string" },
-          followers: { type: "number" },
-          verified: { type: "boolean" },
-        },
-        required: ["username"],
-      },
-      posts: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "string" },
-            likes: { type: "number" },
-            caption: { type: "string" },
-          },
-        },
-      },
-    },
-    required: ["profile"],
-  },
-};
-
-// Validate the schema
-vana.data.validateDataSchema(instagramSchema);
+When working with the SDK:
 
-// Validate user data against the schema
-const userData = {
-  profile: { username: "alice_smith", followers: 1500, verified: false },
-  posts: [{ id: "post_123", likes: 42, caption: "Beautiful sunset! 🌅" }],
-};
+1. **Never edit generated files** - They are overwritten on regeneration
+2. **Regenerate after schema changes** - Run generation scripts when external schemas change
+3. **Generated files are committed** - They're included in version control for consistency
+4. **ESLint ignores generated code** - Style rules don't apply to generated files
 
-vana.data.validateDataAgainstSchema(userData, instagramSchema);
+```bash
+# Regenerate all code after schema updates
+npm run fetch-abis
+npm run fetch-server-types
+npm run codegen:subgraph
 ```
 
-## Contributing
-
-We welcome contributions to the Vana SDK! Please see our [Contributing Guide](../../CONTRIBUTING.md) for details.
-
-### Development Setup
+## Development
 
 ```bash
 git clone https://github.com/vana-com/vana-sdk.git
@@ -572,29 +421,6 @@ npm run build
 npm test
 ```
 
-### Running Examples
-
-```bash
-cd examples/vana-sdk-demo
-npm install
-npm run dev
-```
-
-## Documentation
-
-- [📚 API Documentation](https://vana-com.github.io/vana-sdk) - Complete TypeDoc API reference
-- [🚀 Getting Started Guide](https://docs.vana.org/vana-sdk) - Step-by-step setup
-- [🏗️ Architecture Guide](https://docs.vana.org/vana-sdk/architecture) - SDK design and patterns
-- [🔧 Configuration Guide](https://docs.vana.org/vana-sdk/configuration) - All configuration options
-- [🔒 Security Guide](https://docs.vana.org/vana-sdk/security) - Best practices and security
-
-## Support
-
-- **📖 Documentation**: [API Reference](https://vana-com.github.io/vana-sdk)
-- **💬 Discord**: [Join our community](https://discord.gg/vanabuilders)
-- **🐛 Issues**: [GitHub Issues](https://github.com/vana-com/vana-sdk/issues)
-- **📧 Email**: [support@vana.org](mailto:support@vana.org)
-
 ## License
 
 [ISC License](LICENSE) © Vana Foundation