ppi-sdk 1.0.0

package/src/primitives/SEND.js

@@ -0,0 +1,65 @@
+// UPDATED: Consistent with backend field names
+export function createSend(amount) {
+  const state = {
+    amount,
+    to_user: null,  // ✅ Changed to underscore
+    message: '',
+    fee: 'auto',
+    currency: 'CASHA',
+    confirmations: 2,
+    priority: 'standard',
+    operation: 'PPI_SEND'  // ✅ Added operation type
+  };
+
+  return {
+    to(recipient) {
+      state.to_user = recipient;  // ✅ Store as to_user
+      return this;
+    },
+    
+    withMessage(text) {
+      state.message = text;
+      return this;
+    },
+    
+    withFee(cost) {
+      state.fee = cost;
+      return this;
+    },
+    
+    withConfirmations(count) {
+      state.confirmations = count;
+      return this;
+    },
+    
+    withPriority(level) {
+      state.priority = level;
+      return this;
+    },
+    
+    compile(target = 'casha-dag') {
+      return {
+        type: 'DAG_TRANSACTION',
+        version: '1.0',
+        operation: 'SEND',
+        parameters: { 
+          ...state,
+          from_user: '{{current_user}}'  // ✅ Added template for DAGIntegration
+        }
+      };
+    },
+    
+    toString() {
+      return `PPI_SEND(${state.amount}).TO(${state.to_user})`;  // ✅ Updated display
+    },
+    
+    toJSON() {
+      return { ...state };
+    },
+    
+    // Get current state
+    getState() {
+      return { ...state };
+    }
+  };
+}

package/src/primitives/SPLIT.js

@@ -0,0 +1,55 @@
+// C:\Casha\ppi-universe\src\primitives\split.js
+// Updated to match your exact pattern
+
+export function createSplit(amount) {
+  const state = {
+    amount,
+    recipients: [],
+    distribution: 'equal',
+    operation: 'PPI_SPLIT',
+    message: ''
+  };
+
+  return {
+    among(recipients) {
+      state.recipients = recipients;
+      return this;
+    },
+    
+    equal() {
+      state.distribution = 'equal';
+      return this;
+    },
+    
+    withMessage(text) {
+      state.message = text;
+      return this;
+    },
+    
+    compile() {
+      const share = state.amount / state.recipients.length;
+      return {
+        type: 'DAG_BATCH',
+        version: '1.0',
+        operation: 'BATCH_SEND',
+        parameters: {
+          transactions: state.recipients.map(recipient => ({
+            from_user: '{{current_user}}',
+            to_user: recipient,
+            amount: Math.round(share * 100) / 100,
+            currency: 'CASHA',
+            message: state.message || `Split payment: ${share} each`
+          }))
+        }
+      };
+    },
+    
+    toString() {
+      return `PPI_SPLIT(${state.amount}).AMONG([${state.recipients.join(', ')}])`;
+    },
+    
+    getState() { 
+      return { ...state }; 
+    }
+  };
+}

package/src/primitives/STREAM.js

@@ -0,0 +1,113 @@
+// C:\Casha\ppi-universe\src\primitives\stream.js
+// PPI_STREAM - Real-time continuous payment streams
+
+export function createStream(amount) {
+  const state = {
+    amount,
+    to_user: null,
+    stream_type: 'duration', // duration, until, perpetual
+    duration: null,
+    interval: 'second', // second, minute, hour, day
+    start_time: new Date().toISOString(),
+    end_time: null,
+    message: '',
+    fee: 'auto',
+    operation: 'PPI_STREAM',
+    auto_renew: false,
+    stream_id: null
+  };
+
+  return {
+    TO(recipient) {
+      state.to_user = recipient;
+      return this;
+    },
+
+    OVER(duration) {
+      state.stream_type = 'duration';
+      state.duration = duration;
+      return this;
+    },
+
+    PER(interval) {
+      state.interval = interval;
+      return this;
+    },
+
+    UNTIL(endTime) {
+      state.stream_type = 'until';
+      state.end_time = new Date(endTime).toISOString();
+      return this;
+    },
+
+    STARTING(startTime) {
+      state.start_time = new Date(startTime).toISOString();
+      return this;
+    },
+
+    WITH_MESSAGE(text) {
+      state.message = text;
+      return this;
+    },
+
+    WITH_AUTO_RENEW(renew = true) {
+      state.auto_renew = renew;
+      return this;
+    },
+
+    // For perpetual streams (no end)
+    PERPETUAL() {
+      state.stream_type = 'perpetual';
+      return this;
+    },
+
+    compile(target = 'casha-dag') {
+      // Calculate rate per interval
+      state.rate_per_interval = this._calculateRate();
+      
+      return {
+        type: 'PPI_OPERATION',
+        operation: 'PPI_STREAM',
+        target: target,
+        parameters: { ...state }
+      };
+    },
+
+    _calculateRate() {
+      if (state.stream_type === 'duration' && state.duration) {
+        const totalIntervals = this._getTotalIntervals();
+        return state.amount / totalIntervals;
+      }
+      return state.amount; // For perpetual or until streams
+    },
+
+    _getTotalIntervals() {
+      const intervalMultipliers = {
+        'second': 1,
+        'minute': 60,
+        'hour': 3600,
+        'day': 86400
+      };
+      
+      return state.duration * (intervalMultipliers[state.interval] || 1);
+    },
+
+    toString() {
+      if (state.stream_type === 'duration') {
+        return `PPI_STREAM(${state.amount}).TO(${state.to_user}).OVER(${state.duration}).${state.interval.toUpperCase()}S`;
+      } else if (state.stream_type === 'until') {
+        return `PPI_STREAM(${state.amount}).TO(${state.to_user}).UNTIL(${state.end_time})`;
+      } else {
+        return `PPI_STREAM(${state.amount}).TO(${state.to_user}).PERPETUAL()`;
+      }
+    },
+
+    toJSON() {
+      return { ...state };
+    },
+
+    getState() {
+      return { ...state };
+    }
+  };
+}

package/src/primitives/VOTE.js

@@ -0,0 +1,109 @@
+// C:\Casha\ppi-universe\src\primitives\vote.js
+// PPI_VOTE - Multi-party voting and decision systems
+
+export function createVote(proposal) {
+  const state = {
+    proposal,
+    voters: [],
+    vote_type: 'approval', // approval, majority, unanimous, weighted
+    threshold: 0.5, // 50% by default
+    options: ['approve', 'reject'],
+    duration: null,
+    start_time: new Date().toISOString(),
+    end_time: null,
+    action_on_success: null,
+    action_on_failure: null,
+    message: '',
+    operation: 'PPI_VOTE',
+    vote_id: null
+  };
+
+  return {
+    AMONG(voters) {
+      state.voters = Array.isArray(voters) ? voters : [voters];
+      return this;
+    },
+
+    WITH_THRESHOLD(threshold) {
+      state.threshold = threshold;
+      return this;
+    },
+
+    WITH_OPTIONS(options) {
+      state.options = options;
+      return this;
+    },
+
+    WITH_DURATION(duration, unit = 'hours') {
+      state.duration = { value: duration, unit };
+      // Calculate end time
+      const end = new Date(state.start_time);
+      if (unit === 'hours') end.setHours(end.getHours() + duration);
+      else if (unit === 'days') end.setDate(end.getDate() + duration);
+      else if (unit === 'minutes') end.setMinutes(end.getMinutes() + duration);
+      state.end_time = end.toISOString();
+      return this;
+    },
+
+    UNTIL(endTime) {
+      state.end_time = new Date(endTime).toISOString();
+      return this;
+    },
+
+    ON_SUCCESS(action) {
+      state.action_on_success = action;
+      return this;
+    },
+
+    ON_FAILURE(action) {
+      state.action_on_failure = action;
+      return this;
+    },
+
+    WITH_MESSAGE(text) {
+      state.message = text;
+      return this;
+    },
+
+    // Vote type shortcuts
+    MAJORITY() {
+      state.vote_type = 'majority';
+      state.threshold = 0.5;
+      return this;
+    },
+
+    UNANIMOUS() {
+      state.vote_type = 'unanimous';
+      state.threshold = 1.0;
+      return this;
+    },
+
+    WEIGHTED(weights) {
+      state.vote_type = 'weighted';
+      state.weights = weights;
+      return this;
+    },
+
+    compile(target = 'casha-dag') {
+      return {
+        type: 'PPI_OPERATION',
+        operation: 'PPI_VOTE',
+        target: target,
+        parameters: { ...state }
+      };
+    },
+
+    toString() {
+      const votersStr = state.voters.slice(0, 3).join(', ') + (state.voters.length > 3 ? `... (+${state.voters.length - 3})` : '');
+      return `PPI_VOTE("${state.proposal}").AMONG([${votersStr}]).${state.vote_type.toUpperCase()}()`;
+    },
+
+    toJSON() {
+      return { ...state };
+    },
+
+    getState() {
+      return { ...state };
+    }
+  };
+}

package/test/backend-diagnostic.js

@@ -0,0 +1,48 @@
+// test/backend-diagnostic.js
+import { createSend } from '../src/primitives/send.js';
+import { PPICompiler } from '../src/compiler/compiler.js';
+import { DAGIntegration } from '../src/integration/dag-integration.js';
+
+async function diagnoseBackend() {
+  console.log('🔍 Diagnosing Backend Issue\n');
+
+  const dag = new DAGIntegration();
+  
+  // Test with a user that might exist in your database
+  dag.setCurrentUser('existing_user_123'); // Try a user that might exist
+
+  console.log('1. Testing with potential existing user...');
+  const sendOp = createSend(10) // Small amount for testing
+    .to('alice_wallet')
+    .withMessage('Backend diagnostic test');
+
+  const compiled = PPICompiler.compile(sendOp);
+  const result = await dag.executeCompiled(compiled);
+  
+  console.log('Result:', result.message);
+
+  // Test backend endpoints directly
+  console.log('\n2. Testing backend endpoints...');
+  
+  try {
+    // Test health endpoint
+    const health = await fetch('https://casha-backend-production.up.railway.app/health');
+    console.log('Health endpoint:', health.status, health.statusText);
+    
+    // Test if users exist
+    const userCheck = await fetch('https://casha-backend-production.up.railway.app/debug/user/existing_user_123');
+    console.log('User check:', userCheck.status);
+    
+    if (userCheck.status === 200) {
+      const userData = await userCheck.json();
+      console.log('User exists:', userData);
+    } else {
+      console.log('User does not exist or error');
+    }
+    
+  } catch (error) {
+    console.log('Endpoint test error:', error.message);
+  }
+}
+
+diagnoseBackend().catch(console.error);

package/test/check-balance.js

@@ -0,0 +1,28 @@
+// test/check-balance.js
+async function checkBalances() {
+  console.log('💰 Checking Balances for Real Users\n');
+
+  const baseUrl = 'https://casha-backend-production.up.railway.app';
+  const users = [
+    'oscar@casha.com',
+    'davy@casha.com', 
+    'emima@casha.com',
+    'hebrayo@gmail.com'
+  ];
+
+  for (const userId of users) {
+    try {
+      const response = await fetch(`${baseUrl}/debug/balance/${userId}`);
+      if (response.status === 200) {
+        const userData = await response.json();
+        console.log(`✅ ${userId}: ${userData.balance} CASHA`);
+      } else {
+        console.log(`❌ ${userId}: Not found or error`);
+      }
+    } catch (error) {
+      console.log(`❌ ${userId}: ${error.message}`);
+    }
+  }
+}
+
+checkBalances().catch(console.error);

package/test/debug-flow.js

@@ -0,0 +1,58 @@
+// test/debug-flow.js
+import { createSend } from '../src/primitives/send.js';
+import { PPICompiler } from '../src/compiler/compiler.js';
+import { DAGIntegration } from '../src/integration/dag-integration.js';
+
+async function debugFlow() {
+  console.log('🔍 Debugging PPI → DAG Data Flow\n');
+
+  const dag = new DAGIntegration();
+  dag.setCurrentUser('debug_user_' + Date.now());
+
+  // Create operation
+  const sendOp = createSend(50)
+    .to('alice_wallet')
+    .withMessage('Debug test');
+
+  console.log('1. PPI Operation:');
+  console.log('   Expression:', sendOp.toString());
+  console.log('   State:', JSON.stringify(sendOp.getState(), null, 2));
+
+  // Compile
+  const compiled = PPICompiler.compile(sendOp);
+  console.log('\n2. Compiled Operation:');
+  console.log('   Full compiled:', JSON.stringify(compiled, null, 2));
+  console.log('   Parameters:', JSON.stringify(compiled.parameters, null, 2));
+
+  // Check what DAGIntegration will send
+  console.log('\n3. What DAGIntegration will send:');
+  const transactionData = {
+    from_user: dag.currentUser,
+    to_user: compiled.parameters.to_user,
+    amount: compiled.parameters.amount,
+    message: compiled.parameters.message,
+    currency: compiled.parameters.currency,
+    fee: compiled.parameters.fee
+  };
+  
+  console.log('   Transaction data:', JSON.stringify(transactionData, null, 2));
+  console.log('   Wrapped payload:', JSON.stringify({ transaction: transactionData }, null, 2));
+
+  // Test the actual backend call
+  console.log('\n4. Testing backend call...');
+  try {
+    const response = await fetch('https://casha-backend-production.up.railway.app/transaction', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ transaction: transactionData })
+    });
+    
+    console.log('   Response status:', response.status);
+    const result = await response.text();
+    console.log('   Response body:', result);
+  } catch (error) {
+    console.log('   Error:', error.message);
+  }
+}
+
+debugFlow().catch(console.error);

package/test/find-users.js

@@ -0,0 +1,74 @@
+// test/find-users.js
+async function findExistingUsers() {
+  console.log('🔍 Searching for existing users in your database...\n');
+  
+  const baseUrl = 'https://casha-backend-production.up.railway.app';
+  
+  // Common test user IDs to try
+  const testUserIds = [
+    'user_123', 'user_456', 'user_789',
+    'test_user', 'demo_user', 'alice', 'bob', 'charlie',
+    'user1', 'user2', 'user3', 'admin', 'test'
+  ];
+
+  console.log('1. Testing common user IDs:');
+  let foundUsers = [];
+  
+  for (const userId of testUserIds) {
+    try {
+      const response = await fetch(`${baseUrl}/debug/user/${userId}`);
+      if (response.status === 200) {
+        const userData = await response.json();
+        console.log(`   ✅ FOUND: ${userId} - Balance: ${userData.balance}`);
+        foundUsers.push(userData);
+      } else {
+        console.log(`   ❌ Not found: ${userId}`);
+      }
+    } catch (error) {
+      console.log(`   ❌ Error checking ${userId}: ${error.message}`);
+    }
+  }
+
+  // Check recent transactions to find active users
+  console.log('\n2. Checking recent transactions for active users...');
+  try {
+    const response = await fetch(`${baseUrl}/transactions/recent`);
+    if (response.status === 200) {
+      const data = await response.json();
+      if (data.recent_transactions && data.recent_transactions.length > 0) {
+        console.log('   Recent transactions found:');
+        data.recent_transactions.forEach(tx => {
+          console.log(`   - From: ${tx.from_username}, To: ${tx.to_username}`);
+        });
+      } else {
+        console.log('   No recent transactions found');
+      }
+    }
+  } catch (error) {
+    console.log('   Error fetching transactions:', error.message);
+  }
+
+  // Get DAG info which might have user count
+  console.log('\n3. Checking system info...');
+  try {
+    const response = await fetch(baseUrl);
+    if (response.status === 200) {
+      const data = await response.json();
+      console.log(`   Total users: ${data.users_count}`);
+      console.log(`   Total transactions: ${data.transactions_count}`);
+    }
+  } catch (error) {
+    console.log('   Error fetching system info:', error.message);
+  }
+
+  if (foundUsers.length > 0) {
+    console.log('\n🎉 Found existing users! Use these in your tests:');
+    foundUsers.forEach(user => {
+      console.log(`   User ID: ${user.user_id}, Balance: ${user.balance}`);
+    });
+  } else {
+    console.log('\n❌ No existing users found. You need to register users first.');
+  }
+}
+
+findExistingUsers().catch(console.error);

package/test/live-test.js

@@ -0,0 +1,40 @@
+// test/live-test.js
+import { createSend } from '../src/primitives/send.js';
+import { createEscrow } from '../src/primitives/escrow.js';
+import { PPICompiler } from '../src/compiler/compiler.js';
+import { DAGIntegration } from '../src/integration/dag-integration.js';
+
+async function runLiveTest() {
+  console.log('🧪 Testing PPI with Live DAG Integration...\n');
+
+  const dag = new DAGIntegration();
+  
+  // ✅ USE REAL USER IDS FROM YOUR DATABASE!
+  // Replace these with actual user IDs that exist in your backend
+  dag.setCurrentUser('user_123'); // ← Change to REAL user ID from your DB
+  
+  const realRecipient = 'user_456'; // ← Change to REAL user ID from your DB
+
+  console.log('1. Testing PPI_SEND with live DAG...');
+  const sendOp = createSend(10) // Start with small amount
+    .to(realRecipient)
+    .withMessage('Live PPI Test!');
+  
+  const compiledSend = PPICompiler.compile(sendOp);
+  const sendResult = await dag.executeCompiled(compiledSend);
+  console.log('   Send result:', sendResult.message);
+
+  console.log('\n2. Testing PPI_ESCROW with live DAG...');
+  const escrowOp = createEscrow(20)
+    .from('user_123') // Real sender
+    .to(realRecipient) // Real recipient
+    .withArbitrator('marketplace');
+  
+  const compiledEscrow = PPICompiler.compile(escrowOp);
+  const escrowResult = await dag.executeCompiled(compiledEscrow);
+  console.log('   Escrow result:', escrowResult.message);
+
+  console.log('\n🎉 PPI Live Test Complete!');
+}
+
+runLiveTest().catch(console.error);

package/test/multi-chain-test.js

@@ -0,0 +1,76 @@
+// Multi-Chain PPI Test
+import { createSend, createEscrow, createSplit } from '../packages/ppi-sdk/index.js';
+import { PPICompiler } from '../src/compiler/compiler.js';
+
+async function testMultiChain() {
+  console.log('🌐 Testing PPI Multi-Chain Compilation\n');
+
+  // Test addresses (mock Ethereum addresses)
+  const ethAddress = '0x742d35Cc6634C0532925a3b8D4C9db7f7e2d5c5d';
+  const ethAddress2 = '0x8ba1f109551bD432803012645Ac136ddd64DBA72';
+
+  console.log('1. Testing PPI_SEND across chains:');
+  
+  const sendOp = createSend(1.5) // 1.5 ETH
+    .to(ethAddress)
+    .withMessage('Multi-chain test!');
+
+  console.log('   PPI Expression:', sendOp.toString());
+
+  // Compile for different chains
+  try {
+    const cashaCompiled = PPICompiler.compile(sendOp, 'casha-dag');
+    console.log('   ✅ Casha DAG:', cashaCompiled.type);
+  } catch (error) {
+    console.log('   ❌ Casha DAG:', error.message);
+  }
+
+  try {
+    const ethCompiled = PPICompiler.compile(sendOp, 'ethereum');
+    console.log('   ✅ Ethereum:', ethCompiled.type);
+    console.log('      To:', ethCompiled.parameters.to);
+    console.log('      Value:', ethCompiled.parameters.value);
+  } catch (error) {
+    console.log('   ❌ Ethereum:', error.message);
+  }
+
+  console.log('\n2. Testing PPI_ESCROW across chains:');
+  
+  const escrowOp = createEscrow(2.5)
+    .from(ethAddress)
+    .to(ethAddress2)
+    .withArbitrator('0xArbitratorAddress')
+    .releaseWhen(['conditions_met']);
+
+  console.log('   PPI Expression:', escrowOp.toString());
+
+  try {
+    const ethEscrowCompiled = PPICompiler.compile(escrowOp, 'ethereum');
+    console.log('   ✅ Ethereum Escrow:', ethEscrowCompiled.type);
+    console.log('      Contract:', ethEscrowCompiled.contract);
+    console.log('      Method:', ethEscrowCompiled.method);
+  } catch (error) {
+    console.log('   ❌ Ethereum Escrow:', error.message);
+  }
+
+  console.log('\n3. Testing PPI_SPLIT across chains:');
+  
+  const splitOp = createSplit(3.0)
+    .among([ethAddress, ethAddress2, '0xThirdAddress'])
+    .equal();
+
+  console.log('   PPI Expression:', splitOp.toString());
+
+  try {
+    const ethSplitCompiled = PPICompiler.compile(splitOp, 'ethereum');
+    console.log('   ✅ Ethereum Split:', ethSplitCompiled.type);
+    console.log('      Transactions:', ethSplitCompiled.transactions.length);
+  } catch (error) {
+    console.log('   ❌ Ethereum Split:', error.message);
+  }
+
+  console.log('\n🎉 Multi-Chain PPI Test Complete!');
+  console.log('   PPI Protocol is now UNIVERSAL! 🌐');
+}
+
+testMultiChain().catch(console.error);

package/test/quick-test.js

@@ -0,0 +1,15 @@
+// test/quick-test.js
+import { createSend } from '../src/primitives/send.js';
+
+console.log('🚀 Quick PPI Test\n');
+
+const sendOp = createSend(100).to('test_user');
+console.log('✅ PPI_SEND created:', sendOp.toString());
+
+const state = sendOp.getState();
+console.log('✅ State:', state);
+
+const compiled = sendOp.compile();
+console.log('✅ Compiled:', compiled);
+
+console.log('\n🎉 Basic test passed! Primitives are working!');