Overview

The DragonFire Core SDK provides direct access to the fundamental components of the DragonFire ecosystem. This SDK serves as the foundation for interacting with DragonFire's advanced mathematical and geometric computing infrastructure.

Installation

Install the DragonFire Core SDK using your preferred package manager:

npm install @dragonfire/core-sdk

yarn add @dragonfire/core-sdk

Or include it directly in your HTML:

<script src="https://cdn.dragonfire.ai/sdk/core-sdk-1.2.0.js"></script>

Initialization

To use the Core SDK, you first need to initialize it with your API credentials:

import { DragonFireCore } from '@dragonfire/core-sdk';

// Initialize the core SDK
const core = new DragonFireCore({
  apiKey: 'YOUR_API_KEY',
  region: 'us-west',
  securityLevel: 'high',
  logLevel: 'error',
  timeout: 30000
});

// Connect to DragonFire services
await core.connect();

Configuration Options

Core Components

The DragonFire Core SDK provides access to several fundamental components that form the foundation of the DragonFire ecosystem:

Kernel

The DragonFire Kernel is the fractal execution layer that powers all DragonFire services. It provides optimized mathematical processing pathways using phi-resonant patterns.

// Access the Kernel
const kernel = core.kernel;

// Execute a fractal operation
const result = await kernel.execute({
  pattern: 'phi',                    // Mathematical pattern (phi, pi, sqrt2, sqrt3, e)
  dimensions: 7,                     // Processing dimensions (3-13)
  operation: 'transform',            // Operation type
  data: [1, 1, 2, 3, 5, 8, 13],      // Input data
  options: {
    precision: 'high',               // Processing precision
    optimizationLevel: 'maximum',    // Optimization level
    returnFormat: 'array'            // Return format
  }
});

// Process data streams
const stream = kernel.createStream({
  pattern: 'phi',
  dimensions: 7,
  continuousProcessing: true
});

stream.on('data', (processedData) => {
  console.log('Processed data:', processedData);
});

stream.write([1, 1, 2, 3, 5]);
stream.write([8, 13, 21, 34, 55]);

// Close the stream when done
stream.end();

For detailed information on Kernel functions and capabilities, see the complete Kernel documentation.

Cache

The DragonFire Cache provides millisecond-level distributed memory synchronization across services. It enables ultra-low latency data access with fractal-optimized storage patterns.

// Access the Cache
const cache = core.cache;

// Store data in cache
await cache.set('user_profile_123', {
  name: 'Alice',
  preferences: { theme: 'dark', language: 'en' }
}, {
  ttl: 3600,                   // Time-to-live in seconds
  pattern: 'fractal',          // Storage pattern (fractal, linear, network)
  priority: 'high',            // Cache priority
  sync: true                   // Synchronize across nodes
});

// Retrieve data from cache
const userData = await cache.get('user_profile_123');

// Store multiple items
await cache.mset([
  { key: 'key1', value: 'value1', ttl: 3600 },
  { key: 'key2', value: 'value2', ttl: 7200 }
], { pattern: 'fractal' });

// Retrieve multiple items
const multiData = await cache.mget(['key1', 'key2']);

// Delete cache item
await cache.delete('user_profile_123');

// Clear cache region
await cache.clear({ pattern: 'user_*' });

For detailed information on Cache functions and capabilities, see the complete Cache documentation.

DragonHeart

DragonHeart is a harmonic processing engine that utilizes fundamental mathematical constants (Pi, Phi, √2, √3) for optimized computation. It enables advanced pattern recognition and transformation capabilities.

// Access DragonHeart
const heart = core.heart;

// Process data with harmonic patterns
const harmonicResult = await heart.process({
  sequence: [1, 1, 2, 3, 5, 8, 13],   // Input sequence
  pattern: 'fibonacci',                // Sequence pattern
  resonance: 'phi',                    // Resonance pattern
  dimensions: 7,                       // Processing dimensions
  options: {
    precision: 'maximum',              // Processing precision
    iterationLimit: 100,               // Maximum iterations
    convergenceTolerance: 0.0001       // Convergence tolerance
  }
});

// Find pattern resonance
const resonanceResult = await heart.findResonance({
  data: [1.2, 3.5, 8.1, 14.7, 21.3],
  patterns: ['phi', 'pi', 'sqrt2', 'sqrt3', 'e'],
  threshold: 0.85
});

// Transform data using harmonic mapping
const transformedData = await heart.transform({
  source: sourceData,
  sourcePattern: 'logarithmic',
  targetPattern: 'exponential',
  harmonicBase: 'phi'
});

For detailed information on DragonHeart functions and capabilities, see the complete DragonHeart documentation.

DragonCube

DragonCube provides zero-latency geometric compute nodes with a 3x3x3 cube architecture and 7-dimensional center state vectors. It enables high-performance geometric calculations and transformations.

// Access DragonCube
const cube = core.cube;

// Initialize a compute cube
const computeCube = await cube.initialize({
  dimensions: 3,                 // Physical cube dimensions
  centerDimensions: 7,           // Center state vector dimensions
  optimizationPattern: 'phi',    // Optimization pattern
  architecture: 'octahedral'     // Computation architecture
});

// Execute a geometric operation
const result = await computeCube.execute({
  operation: 'transform',
  input: inputData,
  transformationType: 'jitterbug',
  parameters: {
    rotationAngle: Math.PI / 4,
    scaling: 1.5,
    iterations: 3
  }
});

// Perform a dimensional mapping
const mappedData = await computeCube.mapDimensions({
  sourceData: sourceData,
  sourceDimensions: 3,
  targetDimensions: 7,
  mappingFunction: 'harmonic'
});

// Close the compute cube when done
await computeCube.close();

For detailed information on DragonCube functions and capabilities, see the complete DragonCube documentation.

DragonXOS

DragonXOS is the holographic system shell that coordinates all DragonFire components and provides a unified interface. It manages system resources, component communication, and operation scheduling.

// Access DragonXOS
const xos = core.xos;

// Get system status
const systemStatus = await xos.getSystemStatus();
console.log('System status:', systemStatus);

// Register a component
await xos.registerComponent({
  id: 'custom-processor',
  type: 'processor',
  capabilities: ['transform', 'analyze'],
  resources: {
    memory: '256MB',
    cpu: 0.5
  }
});

// Create a processing flow
const flow = await xos.createFlow({
  name: 'data-processing-flow',
  steps: [
    { component: 'input', operation: 'read', output: 'raw-data' },
    { component: 'kernel', operation: 'process', input: 'raw-data', output: 'processed-data' },
    { component: 'custom-processor', operation: 'transform', input: 'processed-data', output: 'final-result' }
  ],
  options: {
    parallelExecution: true,
    optimizationLevel: 'high'
  }
});

// Execute the flow
const result = await flow.execute({
  inputData: sourceData,
  parameters: {
    transformType: 'geometric',
    precision: 'high'
  }
});

// Get system metrics
const metrics = await xos.getMetrics({
  components: ['kernel', 'cache', 'heart'],
  timeRange: '1h',
  resolution: '1m'
});

For detailed information on DragonXOS functions and capabilities, see the complete DragonXOS documentation.

Wallet Integration

The Core SDK provides seamless integration with Dragon Wallets for secure identity management and financial transactions.

import { DragonFireCore } from '@dragonfire/core-sdk';
import { WalletClient } from '@dragonfire/wallet-client';

// Initialize the core SDK
const core = new DragonFireCore({
  apiKey: 'YOUR_API_KEY',
  region: 'us-west'
});
await core.connect();

// Initialize the wallet client with core
const wallet = new WalletClient(core, {
  securityLevel: 'high',
  vectorDimension: 7
});

// Create a wallet
const walletInfo = await wallet.createWallet({
  name: 'Primary Wallet',
  attributes: { purpose: 'development' }
});

// Execute a wallet operation through core
const transactionResult = await core.executeWalletOperation({
  operation: 'transfer',
  walletId: walletInfo.id,
  parameters: {
    recipient: 'recipient-wallet-id',
    amount: 100,
    currency: 'USD',
    memo: 'Test transfer'
  }
});

For detailed information on wallet integration, see the complete Wallet Integration documentation.

Error Handling

The Core SDK provides a comprehensive error handling system that helps identify and resolve issues during operation.

try {
  // Attempt a core operation
  const result = await core.kernel.execute({
    pattern: 'phi',
    dimensions: 7,
    operation: 'transform',
    data: inputData
  });
} catch (error) {
  // Handle specific error types
  if (error.code === 'KERNEL_EXECUTION_ERROR') {
    console.error('Kernel execution failed:', error.message);
    console.error('Operation:', error.details.operation);
    console.error('Pattern:', error.details.pattern);
    
    // Attempt recovery with alternative pattern
    try {
      const recoveryResult = await core.kernel.execute({
        pattern: 'pi', // Try alternative pattern
        dimensions: 7,
        operation: 'transform',
        data: inputData
      });
      console.log('Recovery successful with pi pattern');
    } catch (recoveryError) {
      console.error('Recovery failed:', recoveryError.message);
    }
  } else if (error.code === 'CONNECTION_ERROR') {
    console.error('Connection issue:', error.message);
    await core.reconnect();
  } else {
    console.error('Unknown error:', error);
  }
}

Common Error Codes

Code Examples

Basic Data Processing

import { DragonFireCore } from '@dragonfire/core-sdk';

async function processData() {
  // Initialize the core SDK
  const core = new DragonFireCore({
    apiKey: 'YOUR_API_KEY',
    region: 'us-west'
  });
  await core.connect();
  
  // Prepare sample data
  const sampleData = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
  
  // Process with Kernel
  const kernelResult = await core.kernel.execute({
    pattern: 'phi',
    dimensions: 7,
    operation: 'transform',
    data: sampleData
  });
  console.log('Kernel processing result:', kernelResult);
  
  // Store in Cache
  await core.cache.set('fibonacci-sequence', sampleData, {
    ttl: 3600,
    pattern: 'fractal'
  });
  console.log('Data stored in cache');
  
  // Process with DragonHeart
  const heartResult = await core.heart.process({
    sequence: sampleData,
    pattern: 'fibonacci',
    resonance: 'phi'
  });
  console.log('Heart processing result:', heartResult);
  
  // Disconnect when done
  await core.disconnect();
}

processData().catch(console.error);

Multi-Component Workflow

import { DragonFireCore } from '@dragonfire/core-sdk';

async function runComplexWorkflow(inputData) {
  // Initialize the core SDK
  const core = new DragonFireCore({
    apiKey: 'YOUR_API_KEY',
    region: 'us-west'
  });
  await core.connect();
  
  try {
    // Step 1: Initialize a DragonCube
    const computeCube = await core.cube.initialize({
      dimensions: 3,
      centerDimensions: 7,
      optimizationPattern: 'phi'
    });
    
    // Step 2: Transform input data geometrically
    const transformedData = await computeCube.execute({
      operation: 'transform',
      input: inputData,
      transformationType: 'jitterbug'
    });
    
    // Step 3: Cache the intermediate result
    await core.cache.set('workflow-intermediate', transformedData, {
      ttl: 1800,
      pattern: 'fractal'
    });
    
    // Step 4: Process with DragonHeart
    const processedData = await core.heart.process({
      sequence: transformedData,
      pattern: 'harmonic',
      resonance: 'phi'
    });
    
    // Step 5: Create a system flow with DragonXOS
    const flow = await core.xos.createFlow({
      name: 'final-processing-flow',
      steps: [
        { component: 'input', operation: 'read', output: 'raw-data' },
        { component: 'processor', operation: 'analyze', input: 'raw-data', output: 'analyzed-data' },
        { component: 'output', operation: 'format', input: 'analyzed-data', output: 'final-result' }
      ]
    });
    
    // Step 6: Execute the flow with the processed data
    const finalResult = await flow.execute({
      inputData: processedData,
      parameters: {
        precision: 'high',
        outputFormat: 'structured'
      }
    });
    
    // Close resources
    await computeCube.close();
    
    return finalResult;
  } catch (error) {
    console.error('Workflow error:', error);
    throw error;
  } finally {
    // Ensure proper disconnection
    await core.disconnect();
  }
}

// Example usage
const sampleData = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];

runComplexWorkflow(sampleData)
  .then(result => console.log('Workflow completed:', result))
  .catch(error => console.error('Workflow failed:', error));

Wallet Integration Example

import { DragonFireCore } from '@dragonfire/core-sdk';
import { WalletClient } from '@dragonfire/wallet-client';

async function integratedWalletExample() {
  // Initialize the core SDK
  const core = new DragonFireCore({
    apiKey: 'YOUR_API_KEY',
    region: 'us-west'
  });
  await core.connect();
  
  // Initialize wallet client with core
  const wallet = new WalletClient(core, {
    securityLevel: 'high',
    vectorDimension: 7
  });
  
  try {
    // Create or load a wallet
    let userWallet;
    try {
      userWallet = await wallet.loadWallet('existing-wallet-id');
      console.log('Loaded existing wallet:', userWallet.id);
    } catch (error) {
      userWallet = await wallet.createWallet({
        name: 'New Integrated Wallet',
        attributes: { purpose: 'demonstration' }
      });
      console.log('Created new wallet:', userWallet.id);
    }
    
    // Process data with kernel
    const dataToProcess = [1, 1, 2, 3, 5, 8, 13];
    const processedData = await core.kernel.execute({
      pattern: 'phi',
      dimensions: 7,
      operation: 'transform',
      data: dataToProcess
    });
    
    // Store processed result in cache
    const cacheKey = `wallet:${userWallet.id}:processed-data`;
    await core.cache.set(cacheKey, processedData, {
      ttl: 3600,
      pattern: 'fractal'
    });
    
    // Create a transaction record
    const transactionResult = await wallet.createTransaction({
      recipient: 'recipient-wallet-id',
      amount: processedData[0], // Use processed data in transaction
      currency: 'USD',
      memo: 'Integrated workflow transaction'
    });
    
    // Store transaction in DragonXOS flow
    const flow = await core.xos.createFlow({
      name: 'transaction-recording-flow',
      steps: [
        { component: 'wallet', operation: 'verify', output: 'verified-tx' },
        { component: 'logger', operation: 'record', input: 'verified-tx', output: 'log-entry' },
        { component: 'notification', operation: 'send', input: 'log-entry', output: 'notification' }
      ]
    });
    
    await flow.execute({
      inputData: {
        transaction: transactionResult,
        walletId: userWallet.id
      }
    });
    
    return {
      walletId: userWallet.id,
      processedData: processedData,
      transactionId: transactionResult.id
    };
  } catch (error) {
    console.error('Integration error:', error);
    throw error;
  } finally {
    await core.disconnect();
  }
}

integratedWalletExample()
  .then(result => console.log('Integration successful:', result))
  .catch(error => console.error('Integration failed:', error));