payment-skill 1.0.0

package/src/core/config.ts

@@ -0,0 +1,202 @@
+/**
+ * Payment Skill - Core Configuration Manager
+ * 
+ * Manages application configuration, limits, and emergency stop state
+ */
+
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { 
+  ProviderConfig, 
+  LimitConfig, 
+  TimeWindowConfig, 
+  EmergencyStopState,
+  WiseConfig,
+  BunqConfig 
+} from '../types';
+
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.payment-skill');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const EMERGENCY_FILE = path.join(CONFIG_DIR, 'emergency.json');
+
+export class ConfigManager {
+  private config: any = {};
+  private emergencyState: EmergencyStopState = { active: false, pendingTransactions: [] };
+
+  constructor() {
+    this.ensureConfigDir();
+    this.loadConfig();
+    this.loadEmergencyState();
+  }
+
+  private ensureConfigDir(): void {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+  }
+
+  private loadConfig(): void {
+    if (fs.existsSync(CONFIG_FILE)) {
+      this.config = fs.readJsonSync(CONFIG_FILE);
+    } else {
+      this.config = this.getDefaultConfig();
+      this.saveConfig();
+    }
+  }
+
+  private loadEmergencyState(): void {
+    if (fs.existsSync(EMERGENCY_FILE)) {
+      this.emergencyState = fs.readJsonSync(EMERGENCY_FILE);
+    }
+  }
+
+  private saveConfig(): void {
+    fs.writeJsonSync(CONFIG_FILE, this.config, { spaces: 2 });
+  }
+
+  private saveEmergencyState(): void {
+    fs.writeJsonSync(EMERGENCY_FILE, this.emergencyState, { spaces: 2 });
+  }
+
+  private getDefaultConfig(): any {
+    return {
+      version: '1.0.0',
+      providers: {},
+      limits: {
+        perTransaction: 10000,
+        daily: 50000,
+        weekly: 200000,
+        monthly: 500000,
+        maxTransactionsPerHour: 10
+      },
+      timeWindow: {
+        enabled: false,
+        start: '08:00',
+        end: '22:00',
+        timezone: 'Europe/Bucharest'
+      },
+      blockedCategories: ['gambling', 'adult', 'drugs', 'weapons', 'tobacco'],
+      verifiedMerchantsOnly: true,
+      webhookUrl: null
+    };
+  }
+
+  // Provider Management
+  setProvider(name: string, config: ProviderConfig): void {
+    this.config.providers[name] = config;
+    this.saveConfig();
+  }
+
+  getProvider(name: string): ProviderConfig | null {
+    return this.config.providers[name] || null;
+  }
+
+  getAllProviders(): Record<string, ProviderConfig> {
+    return this.config.providers;
+  }
+
+  removeProvider(name: string): void {
+    delete this.config.providers[name];
+    this.saveConfig();
+  }
+
+  // Limits Management
+  getLimits(): LimitConfig {
+    return this.config.limits;
+  }
+
+  setLimits(limits: Partial<LimitConfig>): void {
+    this.config.limits = { ...this.config.limits, ...limits };
+    this.saveConfig();
+  }
+
+  // Time Window Management
+  getTimeWindow(): TimeWindowConfig {
+    return this.config.timeWindow;
+  }
+
+  setTimeWindow(config: Partial<TimeWindowConfig>): void {
+    this.config.timeWindow = { ...this.config.timeWindow, ...config };
+    this.saveConfig();
+  }
+
+  // Emergency Stop
+  activateEmergencyStop(reason?: string): void {
+    this.emergencyState = {
+      active: true,
+      activatedAt: new Date(),
+      reason: reason || 'Manual activation',
+      pendingTransactions: this.emergencyState.pendingTransactions
+    };
+    this.saveEmergencyState();
+  }
+
+  deactivateEmergencyStop(): void {
+    this.emergencyState = {
+      active: false,
+      pendingTransactions: []
+    };
+    this.saveEmergencyState();
+  }
+
+  isEmergencyStopActive(): boolean {
+    return this.emergencyState.active;
+  }
+
+  getEmergencyStopState(): EmergencyStopState {
+    return this.emergencyState;
+  }
+
+  addPendingTransaction(transactionId: string): void {
+    if (!this.emergencyState.pendingTransactions.includes(transactionId)) {
+      this.emergencyState.pendingTransactions.push(transactionId);
+      this.saveEmergencyState();
+    }
+  }
+
+  removePendingTransaction(transactionId: string): void {
+    this.emergencyState.pendingTransactions = 
+      this.emergencyState.pendingTransactions.filter(id => id !== transactionId);
+    this.saveEmergencyState();
+  }
+
+  // General Config
+  getConfig(): any {
+    return this.config;
+  }
+
+  setConfig(key: string, value: any): void {
+    this.config[key] = value;
+    this.saveConfig();
+  }
+
+  // Blocked Categories
+  getBlockedCategories(): string[] {
+    return this.config.blockedCategories;
+  }
+
+  addBlockedCategory(category: string): void {
+    if (!this.config.blockedCategories.includes(category)) {
+      this.config.blockedCategories.push(category);
+      this.saveConfig();
+    }
+  }
+
+  removeBlockedCategory(category: string): void {
+    this.config.blockedCategories = 
+      this.config.blockedCategories.filter((c: string) => c !== category);
+    this.saveConfig();
+  }
+
+  // Webhook URL
+  getWebhookUrl(): string | null {
+    return this.config.webhookUrl;
+  }
+
+  setWebhookUrl(url: string): void {
+    this.config.webhookUrl = url;
+    this.saveConfig();
+  }
+}
+
+export const configManager = new ConfigManager();

package/src/core/template-engine.ts

@@ -0,0 +1,454 @@
+/**
+ * Payment Skill - Template Engine
+ * 
+ * Implements the configurable template-based payment flow system
+ * OpenClaw selects templates and provides parameters
+ * Payment-skill executes the predefined flow
+ */
+
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { CommandTemplate, TemplateStep, Transaction } from '../types';
+import { WiseClient } from '../api/wise';
+import { BunqClient } from '../api/bunq';
+import { configManager } from './config';
+import { transactionManager } from './transaction';
+
+const TEMPLATES_DIR = path.join(__dirname, '../../templates');
+
+export class TemplateEngine {
+  private templates: Map<string, CommandTemplate> = new Map();
+
+  constructor() {
+    this.loadTemplates();
+  }
+
+  private loadTemplates(): void {
+    // Ensure templates directory exists
+    if (!fs.existsSync(TEMPLATES_DIR)) {
+      fs.mkdirSync(TEMPLATES_DIR, { recursive: true });
+      this.createDefaultTemplates();
+    }
+
+    // Load all template files
+    const files = fs.readdirSync(TEMPLATES_DIR).filter(f => f.endsWith('.json'));
+    
+    for (const file of files) {
+      const template = fs.readJsonSync(path.join(TEMPLATES_DIR, file));
+      this.templates.set(template.templateId, template);
+    }
+  }
+
+  private createDefaultTemplates(): void {
+    const defaultTemplates: CommandTemplate[] = [
+      {
+        templateId: 'wise_standard_transfer',
+        merchant: 'wise.com',
+        version: '1.0.0',
+        description: 'Standard Wise transfer flow with PSD2 confirmation',
+        prerequisites: {
+          apiKey: 'required',
+          webhookEndpoint: 'recommended'
+        },
+        steps: [
+          {
+            order: 1,
+            name: 'create_quote',
+            command: 'wise.createQuote',
+            params: {
+              profileId: '{{profileId}}',
+              sourceCurrency: '{{sourceCurrency}}',
+              targetCurrency: '{{targetCurrency}}',
+              sourceAmount: '{{amount}}'
+            },
+            output: {
+              quoteId: 'id',
+              rate: 'rate',
+              fee: 'fee'
+            }
+          },
+          {
+            order: 2,
+            name: 'create_transfer',
+            command: 'wise.createTransfer',
+            params: {
+              profileId: '{{profileId}}',
+              quoteId: '{{quoteId}}',
+              targetAccountId: '{{recipientId}}',
+              reference: '{{reference}}'
+            },
+            output: {
+              transferId: 'id',
+              status: 'status'
+            },
+            async: true
+          },
+          {
+            order: 3,
+            name: 'fund_transfer',
+            command: 'wise.fundTransfer',
+            params: {
+              profileId: '{{profileId}}',
+              transferId: '{{transferId}}'
+            },
+            async: true,
+            confirmation: {
+              type: 'webhook',
+              events: ['transfer.completed', 'transfer.failed'],
+              timeout: 300
+            }
+          }
+        ],
+        errorHandling: {
+          retryOn: ['network_error', 'rate_limit'],
+          maxRetries: 3,
+          fallback: 'cancel_transfer'
+        }
+      },
+      {
+        templateId: 'bunq_instant_payment',
+        merchant: 'bunq.com',
+        version: '1.0.0',
+        description: 'Instant Bunq payment to IBAN',
+        prerequisites: {
+          apiKey: 'required',
+          webhookEndpoint: 'optional'
+        },
+        steps: [
+          {
+            order: 1,
+            name: 'create_payment',
+            command: 'bunq.createPayment',
+            params: {
+              userId: '{{userId}}',
+              accountId: '{{accountId}}',
+              amount: '{{amount}}',
+              currency: '{{currency}}',
+              counterpartyIban: '{{recipientIban}}',
+              counterpartyName: '{{recipientName}}',
+              description: '{{description}}'
+            },
+            output: {
+              paymentId: 'id',
+              status: 'status'
+            }
+          }
+        ],
+        errorHandling: {
+          retryOn: ['network_error'],
+          maxRetries: 2
+        }
+      },
+      {
+        templateId: 'bunq_payment_request',
+        merchant: 'bunq.com',
+        version: '1.0.0',
+        description: 'Request payment from someone via Bunq',
+        prerequisites: {
+          apiKey: 'required'
+        },
+        steps: [
+          {
+            order: 1,
+            name: 'create_request',
+            command: 'bunq.createRequestInquiry',
+            params: {
+              userId: '{{userId}}',
+              accountId: '{{accountId}}',
+              amount: '{{amount}}',
+              currency: '{{currency}}',
+              counterpartyAlias: {
+                type: '{{recipientType}}',
+                value: '{{recipientValue}}'
+              },
+              description: '{{description}}'
+            },
+            output: {
+              requestId: 'id',
+              status: 'status'
+            },
+            async: true,
+            confirmation: {
+              type: 'poll',
+              timeout: 86400,
+              pollInterval: 60
+            }
+          }
+        ],
+        errorHandling: {
+          retryOn: ['network_error'],
+          maxRetries: 3
+        }
+      },
+      {
+        templateId: 'stripe_connect_charge',
+        merchant: 'stripe.com',
+        version: '1.0.0',
+        description: 'Create charge through Stripe Connect',
+        prerequisites: {
+          apiKey: 'required',
+          webhookEndpoint: 'required'
+        },
+        steps: [
+          {
+            order: 1,
+            name: 'create_payment_intent',
+            command: 'stripe.paymentIntents.create',
+            params: {
+              amount: '{{amount}}',
+              currency: '{{currency}}',
+              customer: '{{customerId}}',
+              automatic_payment_methods: { enabled: true }
+            },
+            output: {
+              paymentIntentId: 'id',
+              clientSecret: 'client_secret',
+              status: 'status'
+            },
+            async: true
+          },
+          {
+            order: 2,
+            name: 'confirm_payment',
+            command: 'stripe.paymentIntents.confirm',
+            params: {
+              paymentIntentId: '{{paymentIntentId}}'
+            },
+            condition: 'requires_confirmation',
+            async: true,
+            confirmation: {
+              type: 'webhook',
+              events: ['payment_intent.succeeded', 'payment_intent.payment_failed'],
+              timeout: 600
+            }
+          }
+        ],
+        errorHandling: {
+          retryOn: ['network_error', 'idempotency_error'],
+          maxRetries: 3
+        }
+      }
+    ];
+
+    for (const template of defaultTemplates) {
+      const filePath = path.join(TEMPLATES_DIR, `${template.templateId}.json`);
+      fs.writeJsonSync(filePath, template, { spaces: 2 });
+      this.templates.set(template.templateId, template);
+    }
+  }
+
+  getTemplate(templateId: string): CommandTemplate | null {
+    return this.templates.get(templateId) || null;
+  }
+
+  getAllTemplates(): CommandTemplate[] {
+    return Array.from(this.templates.values());
+  }
+
+  getTemplatesForMerchant(merchant: string): CommandTemplate[] {
+    return this.getAllTemplates().filter(t => t.merchant === merchant);
+  }
+
+  async executeTemplate(
+    templateId: string,
+    params: Record<string, any>
+  ): Promise<Transaction> {
+    const template = this.getTemplate(templateId);
+    if (!template) {
+      throw new Error(`Template '${templateId}' not found`);
+    }
+
+    // Check emergency stop
+    if (configManager.isEmergencyStopActive()) {
+      throw new Error('Emergency stop is active. Cannot execute template.');
+    }
+
+    // Create transaction record
+    const tx = transactionManager.createTransaction(
+      template.merchant,
+      templateId,
+      parseFloat(params.amount) || 0,
+      params.currency || 'EUR',
+      { templateId, params }
+    );
+
+    try {
+      // Execute each step
+      const context: Record<string, any> = { ...params };
+      
+      for (const step of template.steps.sort((a, b) => a.order - b.order)) {
+        await this.executeStep(step, context, tx);
+      }
+
+      transactionManager.updateTransactionStatus(tx.id, 'completed');
+      return tx;
+    } catch (error: any) {
+      transactionManager.updateTransactionStatus(tx.id, 'failed', error.message);
+      throw error;
+    }
+  }
+
+  private async executeStep(
+    step: TemplateStep,
+    context: Record<string, any>,
+    tx: Transaction
+  ): Promise<void> {
+    // Replace template variables with actual values
+    const resolvedParams = this.resolveParams(step.params, context);
+    
+    // Execute the command
+    const result = await this.executeCommand(step.command, resolvedParams);
+    
+    // Store outputs in context for subsequent steps
+    if (step.output && result) {
+      for (const [key, path] of Object.entries(step.output)) {
+        context[key] = this.getNestedValue(result, path);
+      }
+    }
+
+    // Handle async steps
+    if (step.async && step.confirmation) {
+      await this.waitForConfirmation(step.confirmation, context, tx);
+    }
+  }
+
+  private resolveParams(params: any, context: Record<string, any>): any {
+    if (typeof params === 'string') {
+      // Replace {{variable}} with context value
+      return params.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+        return context[key] !== undefined ? context[key] : match;
+      });
+    }
+    
+    if (Array.isArray(params)) {
+      return params.map(p => this.resolveParams(p, context));
+    }
+    
+    if (typeof params === 'object' && params !== null) {
+      const resolved: any = {};
+      for (const [key, value] of Object.entries(params)) {
+        resolved[key] = this.resolveParams(value, context);
+      }
+      return resolved;
+    }
+    
+    return params;
+  }
+
+  private getNestedValue(obj: any, path: string): any {
+    return path.split('.').reduce((o, p) => o?.[p], obj);
+  }
+
+  private async executeCommand(command: string, params: any): Promise<any> {
+    const [provider, method] = command.split('.');
+    
+    switch (provider) {
+      case 'wise':
+        return this.executeWiseCommand(method, params);
+      case 'bunq':
+        return this.executeBunqCommand(method, params);
+      case 'stripe':
+        // Stripe implementation would go here
+        throw new Error('Stripe commands not yet implemented');
+      default:
+        throw new Error(`Unknown provider: ${provider}`);
+    }
+  }
+
+  private async executeWiseCommand(method: string, params: any): Promise<any> {
+    const config = configManager.getProvider('wise');
+    if (!config) {
+      throw new Error('Wise not configured');
+    }
+    
+    const client = new WiseClient(config as any);
+    
+    switch (method) {
+      case 'createQuote':
+        return client.createQuote(
+          params.profileId,
+          params.sourceCurrency,
+          params.targetCurrency,
+          parseFloat(params.sourceAmount)
+        );
+      case 'createTransfer':
+        return client.createTransfer(
+          params.profileId,
+          params.quoteId,
+          params.targetAccountId,
+          params.reference
+        );
+      case 'fundTransfer':
+        return client.fundTransfer(params.profileId, params.transferId);
+      default:
+        throw new Error(`Unknown Wise command: ${method}`);
+    }
+  }
+
+  private async executeBunqCommand(method: string, params: any): Promise<any> {
+    const config = configManager.getProvider('bunq');
+    if (!config) {
+      throw new Error('Bunq not configured');
+    }
+    
+    const client = new BunqClient(config as any);
+    
+    switch (method) {
+      case 'createPayment':
+        return client.createPayment(
+          params.userId,
+          params.accountId,
+          params.amount,
+          params.currency,
+          params.counterpartyIban,
+          params.counterpartyName,
+          params.description
+        );
+      case 'createRequestInquiry':
+        return client.createRequestInquiry(
+          params.userId,
+          params.accountId,
+          params.amount,
+          params.currency,
+          params.counterpartyAlias,
+          params.description
+        );
+      default:
+        throw new Error(`Unknown Bunq command: ${method}`);
+    }
+  }
+
+  private async waitForConfirmation(
+    confirmation: any,
+    context: Record<string, any>,
+    tx: Transaction
+  ): Promise<void> {
+    const { type, timeout, events, pollInterval } = confirmation;
+    
+    if (type === 'webhook') {
+      // Webhook confirmation - wait for webhook handler to update
+      console.log(`Waiting for webhook confirmation (${timeout}s)...`);
+      // In real implementation, this would set up a promise that resolves on webhook
+      await new Promise(resolve => setTimeout(resolve, 5000));
+    } else if (type === 'poll') {
+      // Polling confirmation
+      const startTime = Date.now();
+      const timeoutMs = (timeout || 300) * 1000;
+      
+      while (Date.now() - startTime < timeoutMs) {
+        // Poll for status
+        await new Promise(resolve => setTimeout(resolve, (pollInterval || 5) * 1000));
+        
+        // Check if confirmed
+        const updatedTx = transactionManager.getTransaction(tx.id);
+        if (updatedTx?.status === 'completed') {
+          return;
+        }
+      }
+      
+      throw new Error('Confirmation timeout');
+    }
+  }
+}
+
+export const templateEngine = new TemplateEngine();