ppi-sdk 1.0.0

package/packages/ppi-sdk/src/primitives/ESCROW.js

@@ -0,0 +1,143 @@
+// C:\Casha\ppi-universe\src\primitives\escrow.js
+// UPDATED: Added condition support and timeout functionality
+
+export function createEscrow(amount) {
+  const state = {
+    amount,
+    from_user: null,  // ✅ Changed to underscore
+    to_user: null,    // ✅ Changed to underscore
+    arbitrator: null,
+    conditions: [],
+    status: 'pending', // pending, released, refunded, disputed
+    message: '',
+    fee: 'auto',
+    operation: 'PPI_ESCROW',  // ✅ Added operation type
+    // NEW: Condition support
+    timeout_condition: null,
+    fallback_action: null,
+    release_reason: '',
+    refund_reason: '',
+    dispute_reason: ''
+  };
+
+  return {
+    from(sender) {
+      state.from_user = sender;  // ✅ Store as from_user
+      return this;
+    },
+
+    to(recipient) {
+      state.to_user = recipient;  // ✅ Store as to_user
+      return this;
+    },
+
+    withArbitrator(arbitrator) {
+      state.arbitrator = arbitrator;
+      return this;
+    },
+
+    // ENHANCED: Now supports both string and condition objects
+    releaseWhen(conditions) {
+      if (Array.isArray(conditions)) {
+        state.conditions = conditions.map(cond => 
+          typeof cond === 'string' ? cond : cond.compile()
+        );
+      } else {
+        state.conditions = [conditions.compile()];
+      }
+      return this;
+    },
+
+    // NEW: Timeout support with fallback action
+    withTimeout(duration, fallbackAction) {
+      // This would use your actual time condition primitive
+      // For now, we'll store the raw duration
+      state.timeout_condition = {
+        type: 'time_after',
+        duration: duration,
+        timestamp: Date.now() + (30 * 24 * 60 * 60 * 1000) // 30 days from now
+      };
+      state.fallback_action = fallbackAction;
+      return this;
+    },
+
+    withMessage(text) {
+      state.message = text;
+      return this;
+    },
+
+    withFee(cost) {
+      state.fee = cost;
+      return this;
+    },
+
+    // Actions
+    async release(reason = 'Conditions met') {
+      if (state.status !== 'pending') {
+        throw new Error(`Escrow is already ${state.status}`);
+      }
+      state.status = 'released';
+      state.release_reason = reason;
+      return this.compile();
+    },
+
+    async refund(reason = 'Agreement cancelled') {
+      if (state.status !== 'pending') {
+        throw new Error(`Escrow is already ${state.status}`);
+      }
+      state.status = 'refunded';
+      state.refund_reason = reason;
+      return this.compile();
+    },
+
+    dispute(reason) {
+      state.status = 'disputed';
+      state.dispute_reason = reason;
+      return this;
+    },
+
+    // ENHANCED Compilation with condition support
+    compile(target = 'casha-dag') {
+      const compiledParams = { 
+        ...state,
+        from_user: state.from_user || '{{current_user}}'  // ✅ Template if not set
+      };
+
+      // Remove non-serializable properties for DAG
+      delete compiledParams.fallback_action;
+
+      return {
+        type: 'DAG_TRANSACTION',
+        version: '1.0',
+        operation: 'ESCROW_CREATE',  // ✅ Match backend operation name
+        parameters: compiledParams
+      };
+    },
+
+    toString() {
+      const conditionStr = state.conditions.length > 0 
+        ? `.RELEASE_WHEN([${state.conditions.length} conditions])`
+        : '';
+      
+      const timeoutStr = state.timeout_condition 
+        ? `.WITH_TIMEOUT(${state.timeout_condition.duration})`
+        : '';
+
+      return `PPI_ESCROW(${state.amount}).FROM(${state.from_user}).TO(${state.to_user})${conditionStr}${timeoutStr}`;
+    },
+
+    toJSON() {
+      return { 
+        ...state,
+        // Handle condition objects in JSON serialization
+        conditions: state.conditions.map(cond => 
+          typeof cond === 'string' ? cond : cond.toJSON ? cond.toJSON() : cond
+        )
+      };
+    },
+
+    getState() {
+      return { ...state };
+    }
+  };
+}

package/packages/ppi-sdk/src/primitives/IF.js

@@ -0,0 +1,67 @@
+// C:\Casha\ppi-universe\src\primitives\if.js
+// FIXED: Proper validation and error handling
+
+export function createIf(condition) {
+  const state = {
+    condition,
+    then_action: null,
+    else_action: null,
+    operation: 'PPI_IF'
+  };
+
+  return {
+    THEN(action) {
+      // Check if action has compile method (is a PPI primitive)
+      if (!action || typeof action.compile !== 'function') {
+        throw new Error('THEN action must be a PPI primitive with compile method');
+      }
+      state.then_action = action;
+      return this;
+    },
+
+    ELSE(action) {
+      if (action && typeof action.compile !== 'function') {
+        throw new Error('ELSE action must be a PPI primitive with compile method');
+      }
+      state.else_action = action;
+      return this;
+    },
+
+    compile(target = 'casha-dag') {
+      if (!state.then_action) {
+        throw new Error('PPI_IF requires a THEN action');
+      }
+
+      return {
+        type: 'DAG_TRANSACTION',
+        version: '1.0',
+        operation: 'CONDITIONAL_EXECUTE',
+        parameters: {
+          condition: state.condition.compile(),
+          then_branch: state.then_action.compile(),
+          else_branch: state.else_action?.compile() || null,
+          operation: state.operation
+        }
+      };
+    },
+
+    toString() {
+      const thenStr = state.then_action ? state.then_action.toString() : 'undefined';
+      const elseStr = state.else_action ? `.ELSE(${state.else_action.toString()})` : '';
+      return `PPI_IF(${state.condition.toString()}).THEN(${thenStr})${elseStr}`;
+    },
+
+    toJSON() {
+      return {
+        ...state,
+        condition: state.condition.toJSON(),
+        then_action: state.then_action?.toJSON(),
+        else_action: state.else_action?.toJSON()
+      };
+    },
+
+    getState() {
+      return { ...state };
+    }
+  };
+}

package/packages/ppi-sdk/src/primitives/RECEIVE.js

@@ -0,0 +1,62 @@
+// C:\Casha\ppi-universe\src\primitives\receive.js
+export function createReceive(amount) {
+  const state = {
+    amount,
+    from_user: null,  // ✅ WHO should send (optional)
+    to_user: null,    // ✅ WHO receives (you)
+    message: '',
+    expires_in: '7d', // ✅ Request timeout
+    currency: 'CASHA',
+    operation: 'PPI_RECEIVE'  // ✅ Changed to RECEIVE for clarity
+  };
+
+  return {
+    from(sender) {  // ✅ Optional: specific sender
+      state.from_user = sender;
+      return this;
+    },
+    
+    to(recipient) {  // ✅ YOU are the recipient
+      state.to_user = recipient;
+      return this;
+    },
+    
+    withMessage(text) {
+      state.message = text;
+      return this;
+    },
+    
+    expiresIn(duration) {
+      state.expires_in = duration;
+      return this;
+    },
+    
+    compile(target = 'casha-dag') {
+      return {
+        type: 'DAG_PAYMENT_REQUEST',  // ✅ Clearer type
+        version: '1.0',
+        operation: 'REQUEST_PAYMENT',     
+        parameters: { 
+          ...state,
+          // No from_user template - filled by sender
+        }
+      };
+    },
+    
+    toString() {
+      const base = `PPI_RECEIVE(${state.amount})`;
+      if (state.from_user) {
+        return `${base}.FROM(${state.from_user})`;
+      }
+      return `${base}.TO(${state.to_user})`;  // ✅ More intuitive
+    },
+    
+    toJSON() {
+      return { ...state };
+    },
+    
+    getState() {
+      return { ...state };
+    }
+  };
+}

package/packages/ppi-sdk/src/primitives/SCHEDULE.js

@@ -0,0 +1,96 @@
+// C:\Casha\ppi-universe\src\primitives\schedule.js
+// PPI_SCHEDULE - Time-based and recurring payments
+
+export function createSchedule(amount) {
+  const state = {
+    amount,
+    to_user: null,
+    schedule_type: 'once', // once, recurring, cron
+    start_time: null,
+    end_time: null,
+    interval: null, // for recurring
+    cron_expression: null,
+    timezone: 'UTC',
+    message: '',
+    fee: 'auto',
+    operation: 'PPI_SCHEDULE',
+    max_occurrences: null
+  };
+
+  return {
+    TO(recipient) {
+      state.to_user = recipient;
+      return this;
+    },
+
+    ON(timestamp) {
+      state.schedule_type = 'once';
+      state.start_time = new Date(timestamp).toISOString();
+      return this;
+    },
+
+    EVERY(interval, unit = 'days') {
+      state.schedule_type = 'recurring';
+      state.interval = { value: interval, unit };
+      return this;
+    },
+
+    STARTING(startTime) {
+      state.start_time = new Date(startTime).toISOString();
+      return this;
+    },
+
+    UNTIL(endTime) {
+      state.end_time = new Date(endTime).toISOString();
+      return this;
+    },
+
+    WITH_CRON(expression) {
+      state.schedule_type = 'cron';
+      state.cron_expression = expression;
+      return this;
+    },
+
+    WITH_TIMEZONE(tz) {
+      state.timezone = tz;
+      return this;
+    },
+
+    WITH_MESSAGE(text) {
+      state.message = text;
+      return this;
+    },
+
+    WITH_MAX_OCCURRENCES(max) {
+      state.max_occurrences = max;
+      return this;
+    },
+
+    compile(target = 'casha-dag') {
+      return {
+        type: 'PPI_OPERATION',
+        operation: 'PPI_SCHEDULE',
+        target: target,
+        parameters: { ...state }
+      };
+    },
+
+    toString() {
+      if (state.schedule_type === 'once') {
+        return `PPI_SCHEDULE(${state.amount}).TO(${state.to_user}).ON(${state.start_time})`;
+      } else if (state.schedule_type === 'recurring') {
+        return `PPI_SCHEDULE(${state.amount}).TO(${state.to_user}).EVERY(${state.interval.value} ${state.interval.unit})`;
+      } else {
+        return `PPI_SCHEDULE(${state.amount}).TO(${state.to_user}).WITH_CRON(${state.cron_expression})`;
+      }
+    },
+
+    toJSON() {
+      return { ...state };
+    },
+
+    getState() {
+      return { ...state };
+    }
+  };
+}

package/packages/ppi-sdk/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/packages/ppi-sdk/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/packages/ppi-sdk/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/packages/ppi-sdk/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 };
+    }
+  };
+}