@reap-protocol/sdk 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,103 @@
+# @reap-protocol/sdk
+
+**The official TypeScript/Node.js SDK for the Reap Protocol: The Agentic Commerce Grid.**
+
+The Reap Protocol enables AI Agents to search for products, register them on-chain, and execute atomic purchases without needing to understand smart contract ABIs. It acts as the bridge between Web2 products data and Web3 commerce settlement.
+
+## 📦 Installation
+```bash
+npm install @reap-protocol/sdk ethers axios
+```
+
+## 🚀 Quick Start
+
+This example demonstrates the full Agentic Commerce Loop: Identity -> Discovery -> Settlement.
+
+### 1. Setup
+
+If using TypeScript, ensure your tsconfig.json targets ES2020 or higher.
+
+### 2. The Agent Code (agent.ts)
+```typescript
+import { ReapClient } from "@reap-protocol/sdk";
+
+// Load your private key securely
+const PRIVATE_KEY = process.env.MY_WALLET_KEY || "";
+
+async function main() {
+  // 1. Initialize the Agent
+  // (Points to official middleware by default)
+  const client = new ReapClient(PRIVATE_KEY);
+  console.log("🤖 Agent Online");
+
+  try {
+    // 2. Identity (One-time setup)
+    // Registers your wallet as an authorized Agent on the Protocol
+    console.log("🆔 Checking Identity...");
+    await client.registerIdentity();
+
+    // 3. JIT Stocking (Discovery)
+    // Searches Web2 (Reap Deals), registers items on-chain, and returns inventory
+    console.log("📦 Stocking Shelf with 'Gaming Laptop'...");
+    const result = await client.stockShelf("Gaming Laptop");
+    
+    const inventory = result.items;
+    console.log(`   🔍 Found ${inventory.length} items on-chain.`);
+
+    if (inventory.length > 0) {
+        // 4. Decision Logic
+        // Example: Pick the first available item
+        const target = inventory[0];
+        console.log(`   🎯 Selected: ${target.name} ($${target.price})`);
+        console.log(`      ID: ${target.id}`);
+
+        // 5. Agentic Cart (Settlement)
+        // Automatically approves USDC and executes the atomic purchase
+        console.log("💸 Buying Item...");
+        const receipt = await client.buyProduct(target.id);
+        
+        if (receipt) {
+            console.log(`🎉 SUCCESS! Transaction Hash: ${receipt.hash}`);
+        }
+    } else {
+        console.log("❌ No items found.");
+    }
+
+  } catch (e: any) {
+    console.error("❌ Error:", e.message);
+  }
+}
+
+main();
+```
+
+### 3. Run It
+```bash
+# Install execution tools if you haven't already
+npm install --save-dev ts-node typescript @types/node
+
+# Run
+npx ts-node agent.ts
+```
+
+## 🔧 Configuration
+
+You can override defaults for custom RPCs or self-hosted middleware.
+```typescript
+const client = new ReapClient(
+  "YOUR_PRIVATE_KEY",
+  "https://base-sepolia.g.alchemy.com/v2/YOUR_KEY", // Custom RPC
+  "https://api.reap.deals"    // Middleware URL
+);
+```
+
+## ✨ Features
+
+* **JIT Stocking**: "Just-In-Time" inventory system. If an agent searches for an item not yet on the blockchain, the Protocol indexes it in real-time.
+* **Agentic Cart**: Automatically routes purchases through the Protocol's batch processor.
+* **Protocol Negotiation**: Built-in support for HTTP 402 Payment Negotiation loops.
+* **Gas Optimized**: Checks on-chain state before sending registration transactions.
+
+## License
+
+MIT

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@reap-protocol/sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc"
   },
   "dependencies": {
-    "axios": "^1.6.0",
+    "axios": "^1.13.2",
     "ethers": "^6.0.0"
   },
   "devDependencies": {
@@ -15,5 +15,9 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Apriloracle/Reap-protocol-sdk.git"
   }
 }

package/src/README.md

@@ -1,58 +1,83 @@
-Reap Protocol
+# @reap-protocol/sdk
 
-The official TypeScript/Node.js SDK for the **Reap Protocol**: The Agentic Commerce Layer.  
-Enable Autonomous Agents to buy and sell on-chain with zero smart contract knowledge.
+**The official TypeScript/Node.js SDK for the Reap Protocol: The Agentic Commerce Grid.**
 
+The Reap Protocol enables AI Agents to search for products, register them on-chain, and execute atomic purchases without needing to understand smart contract ABIs. It acts as the bridge between Web2 products data and Web3 commerce settlement.
 
-
-📦 Installation
-
+## 📦 Installation
+```bash
 npm install @reap-protocol/sdk ethers axios
+```
 
+## 🚀 Quick Start
 
+This example demonstrates the full Agentic Commerce Loop: Identity -> Discovery -> Smart Sync -> Settlement.
 
-🚀 Quick Start
 
-1. Setup
-If using TypeScript, ensure your tsconfig.json targets ES2020 or higher.
+### 1. Setup
 
-2. The Agent Code
+If using TypeScript, ensure your tsconfig.json targets ES2020 or higher.
 
-TypeScript
+### 2. The Agent Code (agent.ts)
+```typescript
 import { ReapClient } from "@reap-protocol/sdk";
 
-// Use a Base Sepolia Wallet
+// Load your private key securely
 const PRIVATE_KEY = process.env.MY_WALLET_KEY || "";
 
+// Optional: Use a specific RPC (e.g., Celo Alfajores or Avalanche Fuji)
+const CHAIN_RPC = "https://api.avax-test.network/ext/bc/C/rpc"; 
+
 async function main() {
-  // 1. Initialize
-  const client = new ReapClient(PRIVATE_KEY);
+  // 1. Initialize the Agent
+  const client = new ReapClient(PRIVATE_KEY, CHAIN_RPC);
+  
+  // Wait for Chain ID initialization
+  await new Promise(r => setTimeout(r, 1000));
   console.log("🤖 Agent Online");
 
   try {
-    // 2. Identity
-    // Ensures this wallet is registered to trade
+    // 2. Identity (One-time setup)
+    // Registers your wallet as an authorized Agent on the Protocol
+    console.log("🆔 Checking Identity...");
     await client.registerIdentity();
 
-    // 3. Discovery (Stocking)
-    // Fetches data, registers it on Base Sepolia, and returns the list
-    console.log("📦 Stocking Shelf...");
-    const result = await client.stockShelf("Tonnino Tuna");
+    // 3. Discovery (Dry Run Mode)
+    // Pass 'true' to get the items AND the transactions without executing them yet.
+    console.log("📦 Browsing for 'Gaming Laptop'...");
     
-    const inventory = result.items;
+    // dryRun = true
+    const result = await client.stockShelf("Gaming Laptop", true); 
+    
+    const inventory = result.items || [];
+    const transactions = result.transactions || [];
+
     console.log(`   🔍 Found ${inventory.length} items.`);
 
     if (inventory.length > 0) {
-        // 4. Decision Engine
-        const target = inventory[0];
-        console.log(`   🎯 Target: ${target.name} ($${target.price})`);
-
-        // 5. Settlement (Agentic Cart)
-        // Automatically approves USDC and executes the purchase
-        console.log("💸 Purchasing...");
-        const receipt = await client.buyProduct(target.id);
+        // 4. Decision Logic
+        // Pick the first item and its corresponding registration transaction
+        const targetItem = inventory[0];
+        const targetTx = transactions[0]; 
+
+        console.log(`   🎯 Selected: ${targetItem.name} ($${targetItem.price})`);
+
+        // 5. Smart Sync (The "Gas Saver")
+        // Checks the Holocron (Index) first. 
+        // If the item exists, it skips registration. 
+        // If not, it executes the targetTx and indexes it.
+        await client.smartSync(targetItem, targetTx);
+
+        // 6. Agentic Cart (Settlement)
+        // Automatically approves USDC and executes the atomic purchase
+        console.log("💸 Buying Item...");
+        const receipt = await client.buyProduct(targetItem.id);
         
-        console.log(`🎉 SUCCESS! Tx: ${receipt.hash}`);
+        if (receipt) {
+            console.log(`🎉 SUCCESS! Transaction Hash: ${receipt.hash}`);
+        }
+    } else {
+        console.log("❌ No items found.");
     }
 
   } catch (e: any) {
@@ -61,26 +86,35 @@ async function main() {
 }
 
 main();
+```
 
+### 3. Run It
+```bash
+# Install execution tools if you haven't already
+npm install --save-dev ts-node typescript @types/node
 
+# Run
+npx ts-node agent.ts
+```
 
-✨ Features
-Typed Interfaces: Full TypeScript support for Product Data and Transactions.
-Agentic Cart: Automatically routes purchases through the Protocol's batch processor.
-Protocol Negotiation: Built-in support for HTTP 402 Payment Negotiation loops.
-Gas Optimized: Checks on-chain state before sending registration transactions.
+## 🔧 Configuration
 
-
-🔧 Configuration
-code
-TypeScript
+You can override defaults for custom RPCs or self-hosted middleware.
+```typescript
 const client = new ReapClient(
   "YOUR_PRIVATE_KEY",
-  "https://sepolia.base.org", // Custom RPC
-  "https://api.reap.deals"    // Middleware URL
+  "https://avax-fuji.g.alchemy.com/v2/YOUR_KEY", // Custom RPC
+  "https://avax2.api.reap.deals"    // Middleware URL
 );
+```
+
+## ✨ Features
 
+* **JIT Stocking**: "Just-In-Time" inventory system. If an agent searches for an item not yet on the blockchain, the Protocol indexes it in real-time.
+* **Agentic Cart**: Automatically routes purchases through the Protocol's batch processor.
+* **Protocol Negotiation**: Built-in support for HTTP 402 Payment Negotiation loops.
+* **Gas Optimized**: Checks on-chain state before sending registration transactions.
 
+## License
 
-License
 MIT

package/src/index.ts

@@ -1,31 +1,60 @@
 import { ethers } from "ethers";
 import axios, { AxiosRequestConfig } from "axios";
 
+const HOLOCRON_ROUTER_ADDRESS = "0x2cEC5Bf3a0D3fEe4E13e8f2267176BdD579F4fd8";
+
+const NETWORKS: Record<string, string> = {
+  "BASE": "https://sepolia.base.org",
+  "AVAX": "https://api.avax-test.network/ext/bc/C/rpc",
+  "CELO": "https://forno.celo-sepolia.celo-testnet.org"
+};
+
+
+const HOLOCRON_ABI = [
+  "function checkExistence(uint256 _c) view returns (bool)",
+  "function stock(uint256 _c) external"
+];
+
 export class ReapClient {
   private wallet: ethers.Wallet;
   private builderUrl: string;
   private provider: ethers.JsonRpcProvider;
+  private holocron: ethers.Contract;
+  private chainId: number = 43113;
 
   constructor(
     privateKey: string, 
-    chainRpc: string = "https://sepolia.base.org", 
-    builderUrl: string = "https://api.reap.deals"
+    chainRpc: string = "https://avalanche-fuji.drpc.org", 
+    builderUrl: string = "https://avax2.api.reap.deals"
   ) {
     this.provider = new ethers.JsonRpcProvider(chainRpc);
     this.wallet = new ethers.Wallet(privateKey, this.provider);
-    this.builderUrl = builderUrl.replace(/\/$/, ""); // Remove trailing slash
-    console.log(`🤖 Reap Agent Online: ${this.wallet.address}`);
+    this.builderUrl = builderUrl.replace(/\/$/, ""); 
+    
+    // Initialize Holocron Contract
+    this.holocron = new ethers.Contract(HOLOCRON_ROUTER_ADDRESS, HOLOCRON_ABI, this.wallet);
+    
+    this.init();
+  }
+
+  private async init() {
+    const net = await this.provider.getNetwork();
+    this.chainId = Number(net.chainId);
+    console.log(`🤖 Reap Agent Online: ${this.wallet.address} (Chain: ${this.chainId})`);
   }
 
   /**
-   * Core Logic: Signs and Broadcasts transactions sequentially.
-   * Uses manual nonce management to prevent RPC lag errors.
+   * Execute Transactions with Nonce & Gas Fixes
    */
   private async executeTransactions(txList: any[]) {
     let lastReceipt;
     
-    // 1. Fetch Nonce ONCE
+    // FIX 1: Use pending nonce
     let currentNonce = await this.provider.getTransactionCount(this.wallet.address, "pending");
+    
+    // FIX 2: Gas Price Buffer (1.1x)
+    const feeData = await this.provider.getFeeData();
+    const gasPrice = feeData.gasPrice ? (feeData.gasPrice * 110n) / 100n : undefined;
 
     for (const txData of txList) {
       const label = txData.label || "Transaction";
@@ -35,33 +64,28 @@ export class ReapClient {
         to: txData.to,
         data: txData.data,
         value: BigInt(txData.value),
-        gasLimit: 500000, // Safety limit
+        gasLimit: 500000,
         nonce: currentNonce,
-        chainId: (await this.provider.getNetwork()).chainId
+        chainId: this.chainId,
+        gasPrice: gasPrice // Apply buffered gas price
       };
 
       try {
-        // 2. Sign & Send
         const response = await this.wallet.sendTransaction(tx);
         console.log(`   🚀 Broadcasting: ${response.hash}`);
         
-        // 3. Wait
         const receipt = await response.wait();
         
-        // 4. Check Status (1 = Success, 0 = Revert)
         if (receipt && receipt.status === 0) {
             throw new Error(`Transaction Reverted! Hash: ${receipt.hash}`);
         }
 
         console.log(`   ✅ Settled on-chain.`);
         lastReceipt = receipt;
-        
-        // 5. Increment Nonce
         currentNonce++;
 
       } catch (e: any) {
         console.error(`   ❌ Tx Failed: ${e.message}`);
-       
         if (label.includes("Approve") || label.includes("Payment")) throw e;
       }
     }
@@ -70,23 +94,84 @@ export class ReapClient {
 
   private async callBuilder(endpoint: string, payload: any) {
     try {
-      const { data } = await axios.post(`${this.builderUrl}${endpoint}`, payload);
-      return data;
+        // Inject Chain ID
+        payload.chain_id = this.chainId;
+        const { data } = await axios.post(`${this.builderUrl}${endpoint}`, payload);
+        return data;
     } catch (error: any) {
       const msg = error.response?.data?.detail || error.message;
       throw new Error(`Reap Protocol Error: ${msg}`);
     }
   }
 
-  // --- PUBLIC API ---
+  // --- SMART AVAILABILITY (Holocron Only) ---
+
+  async checkHolocron(coordinate: string) {
+    console.log(`🔎 Scanning Holocron for ${coordinate}...`);
+    
+    let exists = false;
+    try {
+        exists = await this.holocron.checkExistence(BigInt(coordinate));
+    } catch (e) { exists = false; }
+
+    console.log(`   • Holocron Index: ${exists ? '✅ FOUND' : '❌ EMPTY'}`);
+    return exists;
+  }
+
+  private async indexToHolocron(coordinate: string) {
+    console.log(`   📝 Indexing Coordinate ${coordinate} to Holocron...`);
+    
+    // Re-fetch nonce/gas
+    const nonce = await this.provider.getTransactionCount(this.wallet.address, "pending");
+    const feeData = await this.provider.getFeeData();
+    const gasPrice = feeData.gasPrice ? (feeData.gasPrice * 110n) / 100n : undefined;
+
+    const tx = await this.holocron.stock(BigInt(coordinate), {
+        gasLimit: 150000,
+        nonce,
+        gasPrice
+    });
+    
+    console.log(`   🚀 Broadcast Holocron TX: ${tx.hash}`);
+    await tx.wait();
+    console.log("   ✅ Index Updated.");
+    
+    // Small sleep to let RPC sync
+    await new Promise(r => setTimeout(r, 2000));
+  }
+
+// --- src/index.ts ---
 
-  async getProduct(productId: string) {
-    const safeId = encodeURIComponent(productId);
-    const { data } = await axios.get(`${this.builderUrl}/read/product/${safeId}`);
-    return data;
+  async smartSync(item: any, transaction: any) {
+    const coordinate = item.id;
+    
+    // 1. Check Status
+    const onHolocron = await this.checkHolocron(coordinate);
+
+    if (onHolocron) {
+        console.log("⚡️ Fast Path: Item is indexed. Skipping registration.");
+        return;
+    }
+
+    console.log("\n🐢 Syncing to Chain (Full Path)...");
+
+    // 2. Register Data (if transaction exists)
+    if (transaction) {
+        console.log("   🔸 Registering Data on-chain...");
+        
+        // ⚠️ THE FIX: Wrap the single 'transaction' object in brackets [ ] 
+        // to make it a list, because executeTransactions expects a list.
+        await this.executeTransactions([transaction]);
+        
+    } else {
+        console.log("   ⚠️ No registration transaction provided. Skipping to index.");
+    }
+
+    // 3. Index on Holocron
+    await this.indexToHolocron(coordinate);
   }
 
- // ... inside ReapClient class ...
+  // --- PUBLIC API ---
 
   async registerIdentity(profileUri: string = "ipfs://default") {
     console.log("🆔 Registering Protocol Identity...");
@@ -96,40 +181,41 @@ export class ReapClient {
     });
 
     if (res.status === "already_registered") {
-        console.log(`   ✅ Already Registered (Agent #${res.agent_id}). Skipping transaction.`);
+        console.log(`   ✅ Already Registered (Agent #${res.agent_id}). Skipping.`);
         return null;
     }
-
     return this.executeTransactions(res.transactions);
   }
 
-async stockShelf(productQuery: string) {
-    console.log(`📦 Stocking Shelf: '${productQuery}'`);
+  async stockShelf(productQuery: string, dryRun: boolean = false) {
+    console.log(`📦 Stocking Shelf: '${productQuery}' (Dry Run: ${dryRun})`);
+    
     const res = await this.callBuilder("/build/inventory/stock", {
       product_query: productQuery,
       provider_address: this.wallet.address
     });
 
+    const items = res.meta?.items || [];
+    const transactions = res.transactions || [];
+
     if (res.status === "payment_required") {
-        console.log("🛑 402 Payment Required via JSON Spec.");
-        console.log(`   🧾 Invoice: ${res.meta.description}`);
-    } else {
-        console.log(`   🔍 Found ${res.meta.count || 0} items.`);
+        console.log("🛑 402 Payment Required.");
+        if (dryRun) return { receipt: null, items: [] };
+        const receipt = await this.executeTransactions(transactions);
+        return { receipt, items: [] };
     }
 
-    const receipt = await this.executeTransactions(res.transactions);
+    if (dryRun) {
+        console.log(`   👀 Preview: Found ${items.length} items. Cached ${transactions.length} TXs.`);
+        return { receipt: null, items, transactions };
+    }
 
-    // --- THE FIX: Return both Receipt AND Items ---
-    return {
-        receipt,
-        items: res.meta?.items || []
-    };
-    // ----------------------------------------------
+    const receipt = await this.executeTransactions(transactions);
+    return { receipt, items };
   }
 
   async buyProduct(productId: string) {
     console.log(`💸 Initiating Agentic Cart (Single Item): ${productId}`);
-    // Route to batch endpoint
     const res = await this.callBuilder("/build/commerce/batch", {
       product_ids: [productId]
     });
@@ -143,36 +229,4 @@ async stockShelf(productQuery: string) {
     });
     return this.executeTransactions(res.transactions);
   }
-
-  async fetch(url: string, config: AxiosRequestConfig = {}) {
-    console.log(`🌍 Accessing ${url}...`);
-    try {
-      return await axios.get(url, config);
-    } catch (error: any) {
-      if (error.response && error.response.status === 402) {
-        console.log("🛑 x402 Payment Required. Engaging Protocol...");
-        const header = error.response.headers["www-authenticate"];
-
-        if (header && header.includes("X402")) {
-            const match = header.match(/resource_id="([^"]+)"/);
-            if (match && match[1]) {
-                const rid = match[1];
-                
-                // Pay Protocol
-                const receipt = await this.buyProduct(rid);
-                
-                if (!receipt) throw new Error("Payment Transaction failed");
-                const proof = receipt.hash;
-                
-                console.log(`   🔄 Submitting Proof for Reactive Release: ${proof}`);
-
-                // Release Data
-                const newConfig = { ...config, headers: { ...config.headers, "Authorization": `X402-Proof ${proof}` } };
-                return await axios.get(url, newConfig);
-            }
-        }
-      }
-      throw error;
-    }
-  }
 }