SDK Reference

Complete API reference for the VORT SDK, enabling developers to integrate VORT's intent-centric execution into their applications.

Core Classes

VORT

Main SDK class for interacting with the VORT protocol.

Constructor

new VORT(options: VORTOptions)

Parameters:

• options.apiKey (string, optional): API key for authenticated access

• options.network ('mainnet' | 'devnet', required): Network to connect to

• options.rpcUrl (string, optional): Custom Solana RPC URL

• options.apiUrl (string, optional): Custom VORT API URL

Example:

const vort = new VORT({
  network: 'mainnet',
  apiKey: 'your-api-key'
});

Methods

submitIntent

Submit an intent to the VORT Agent Exchange.

submitIntent(
  intent: Intent,
  options: SubmitOptions
): Promise<SubmitResult>

Parameters:

• intent (Intent): The intent to submit (see Intent Types)

• options.wallet (Wallet): User's Solana wallet

• options.signMessage (function): Function to sign messages with user's wallet

Returns: Promise resolving to SubmitResult:

• intentId (string): Unique identifier for the intent

• status (string): Initial status ('pending' | 'submitted')

• estimatedCost (number): Estimated execution cost in SOL

• estimatedTime (number): Estimated execution time in seconds

Example:

const result = await vort.submitIntent(intent, {
  wallet: userWallet,
  signMessage: async (message) => await userWallet.signMessage(message)
});

getIntentStatus

Get the current status of an intent.

getIntentStatus(intentId: string): Promise<IntentStatus>

Returns: Promise resolving to IntentStatus:

• intentId (string): Intent identifier

• status (string): Current status

• progress (number): Execution progress (0-1)

• currentState (object): Current on-chain state

• actionsCompleted (number): Number of actions completed

• totalActions (number): Total number of actions

Example:

const status = await vort.getIntentStatus(intentId);
console.log(`Status: ${status.status}, Progress: ${status.progress * 100}%`);

monitorIntent

Monitor an intent's execution in real-time using events.

monitorIntent(intentId: string): Promise<IntentMonitor>

Returns: Promise resolving to IntentMonitor with event methods:

• on(event, callback): Register event listener

• off(event, callback): Remove event listener

• once(event, callback): Register one-time event listener

Events:

• 'submitted': Intent submitted to Agent Exchange

• 'auction': Auction in progress (callback receives auction details)

• 'executing': Execution in progress (callback receives progress update)

• 'complete': Execution complete (callback receives receipt)

• 'error': Error occurred (callback receives error)

Example:

const monitor = await vort.monitorIntent(intentId);
monitor.on('complete', (receipt) => {
  console.log('Execution complete!', receipt);
});

getExecutionReceipt

Get the execution receipt for a completed intent.

getExecutionReceipt(intentId: string): Promise<ExecutionReceipt>

Returns: Promise resolving to ExecutionReceipt:

• intentId (string): Intent identifier

• status (string): Final status ('completed' | 'failed')

• finalState (object): Final on-chain state

• proof (object): Cryptographic proof of execution

• transactions (array): On-chain transaction hashes

• costs (object): Execution cost breakdown

• metrics (object): Execution quality metrics

Example:

const receipt = await vort.getExecutionReceipt(intentId);
console.log('Final state:', receipt.finalState);
console.log('Proof:', receipt.proof);

verifyProof

Verify an execution proof independently.

verifyProof(receipt: ExecutionReceipt): Promise<VerificationResult>

Returns: Promise resolving to VerificationResult:

• valid (boolean): Whether the proof is valid

• details (object): Verification details

• errors (array): Any verification errors

Example:

const receipt = await vort.getExecutionReceipt(intentId);
const verification = await vort.verifyProof(receipt);
if (verification.valid) {
  console.log('Proof verified!');
} else {
  console.error('Proof invalid:', verification.errors);
}

getUserPolicies

Get user's current policies.

getUserPolicies(wallet: Wallet): Promise<UserPolicies>

Returns: Promise resolving to UserPolicies object containing policy definitions.

updateUserPolicies

Update user's policies.

updateUserPolicies(
  policies: UserPolicies,
  options: { wallet: Wallet, signMessage: function }
): Promise<void>

Intent Types

SwapIntent

Intent to swap one token for another.

interface SwapIntent {
  type: 'swap';
  from: string;        // Token symbol (e.g., 'SOL')
  to: string;         // Token symbol (e.g., 'USDC')
  amount: number | {  // Amount to swap
    value: number;
    unit: 'absolute' | 'percentage';
  };
  constraints?: {
    maxSlippage?: number;      // Maximum acceptable slippage (0-1)
    maxGasCost?: number;       // Maximum gas cost in SOL
    preferredRoute?: string;   // Preferred routing protocol
    deadline?: number;         // Execution deadline (timestamp)
  };
  policies?: PolicyOverrides;
}

Example:

const swapIntent: SwapIntent = {
  type: 'swap',
  from: 'SOL',
  to: 'USDC',
  amount: 100,
  constraints: {
    maxSlippage: 0.005, // 0.5%
    maxGasCost: 0.01
  }
};

RebalanceIntent

Intent to rebalance portfolio allocation.

interface RebalanceIntent {
  type: 'rebalance';
  target: {           // Target allocation (percentages sum to 1.0)
    [token: string]: number;
  };
  constraints?: {
    maxSlippage?: number;        // Per-trade slippage limit
    rebalanceThreshold?: number; // Minimum drift to trigger rebalance
    maxGasCost?: number;
    preferredProtocols?: string[];
  };
  policies?: PolicyOverrides;
}

Example:

const rebalanceIntent: RebalanceIntent = {
  type: 'rebalance',
  target: {
    SOL: 0.4,  // 40%
    USDC: 0.3, // 30%
    BTC: 0.3   // 30%
  },
  constraints: {
    maxSlippage: 0.005,
    rebalanceThreshold: 0.05 // Rebalance if drift > 5%
  }
};

YieldOptimizeIntent

Intent to optimize yield across protocols.

interface YieldOptimizeIntent {
  type: 'yield_optimize';
  assets: string[];    // Assets to optimize (e.g., ['USDC', 'SOL'])
  constraints?: {
    maxRisk?: number;        // Maximum risk score (0-10)
    minLiquidity?: number;   // Minimum liquidity to maintain (0-1)
    preferredProtocols?: string[];
    maxGasCost?: number;
  };
  policies?: PolicyOverrides;
}

Example:

const yieldIntent: YieldOptimizeIntent = {
  type: 'yield_optimize',
  assets: ['USDC', 'SOL'],
  constraints: {
    maxRisk: 7,
    minLiquidity: 0.2 // Maintain 20% liquidity
  }
};

RiskManageIntent

Intent to set up risk management rules.

interface RiskManageIntent {
  type: 'risk_manage';
  actions: RiskAction[];
  policies?: PolicyOverrides;
}

interface RiskAction {
  condition: string;  // Condition expression (e.g., 'health_factor < 1.2')
  action: 'reduce_leverage' | 'reduce_position' | 'add_collateral' | 'close_position';
  target?: number;    // Target value for the action
  protocol?: string;  // Specific protocol to apply to
}

Example:

const riskIntent: RiskManageIntent = {
  type: 'risk_manage',
  actions: [
    {
      condition: 'health_factor < 1.2',
      action: 'reduce_leverage',
      target: 1.5,
      protocol: 'Drift'
    }
  ]
};

Types and Interfaces

IntentStatus

interface IntentStatus {
  intentId: string;
  status: 'pending' | 'submitted' | 'auction' | 'executing' | 'completed' | 'failed';
  progress: number;           // 0-1
  currentState: object;       // Current on-chain state
  actionsCompleted: number;
  totalActions: number;
  estimatedTimeRemaining?: number; // Seconds
}

ExecutionReceipt

interface ExecutionReceipt {
  intentId: string;
  status: 'completed' | 'failed';
  finalState: object;         // Final on-chain state
  proof: Proof;               // Cryptographic proof
  transactions: string[];      // Transaction hashes
  costs: {
    total: number;             // Total cost in SOL
    fees: number;              // Protocol fees
    gas: number;               // Gas costs
    agentCommission: number;  // Agent commission
  };
  metrics: {
    executionQuality: number;  // 0-1
    priceEfficiency: number;   // 0-1
    slippage: number;          // Actual slippage
    timeToCompletion: number; // Seconds
  };
  timestamp: number;           // Completion timestamp
}

Proof

interface Proof {
  type: 'zk' | 'merkle' | 'signature';
  data: string;                // Proof data (encoded)
  verificationKey: string;     // Public verification key
  timestamp: number;
}

UserPolicies

interface UserPolicies {
  risk?: {
    maxLeverage?: number;
    minHealthFactor?: number;
    maxPositionSize?: number;
    prohibitedProtocols?: string[];
  };
  execution?: {
    maxSlippage?: number;
    preferredSpeed?: 'fast' | 'balanced' | 'cost_optimized';
    maxGasCost?: number;
    timeRestrictions?: {
      days?: number[];         // Days of week (0-6)
      hours?: [number, number]; // [start, end] hours
    };
  };
  protocol?: {
    preferredDEX?: string;
    preferredLending?: string;
    preferredLeverage?: string;
  };
}

Error Handling

Error Types

class VORTError extends Error {
  code: string;
  details: any;
}

// Common error codes:
// - 'INVALID_INTENT': Intent validation failed
// - 'INSUFFICIENT_BALANCE': Insufficient user balance
// - 'POLICY_VIOLATION': Intent violates user policies
// - 'NETWORK_ERROR': Network communication error
// - 'EXECUTION_FAILED': Intent execution failed
// - 'PROOF_INVALID': Proof verification failed

Example:

try {
  await vort.submitIntent(intent, options);
} catch (error) {
  if (error instanceof VORTError) {
    switch (error.code) {
      case 'INVALID_INTENT':
        console.error('Invalid intent:', error.details);
        break;
      case 'INSUFFICIENT_BALANCE':
        console.error('Insufficient balance:', error.details);
        break;
      default:
        console.error('VORT error:', error);
    }
  } else {
    console.error('Unexpected error:', error);
  }
}

Advanced Features

Batch Intent Submission

Submit multiple intents in a single operation:

const results = await vort.submitIntents([intent1, intent2, intent3], options);
// Returns array of SubmitResult objects

Intent Scheduling

Schedule intents for future execution:

const scheduledIntent = {
  ...intent,
  schedule: {
    executeAt: timestamp, // Unix timestamp
    or: {
      condition: 'price(SOL) > 100', // Execute when condition is true
    }
  }
};

Custom Agent Selection

Specify preferred agents or agent requirements:

const intentWithAgentPrefs = {
  ...intent,
  agentPreferences: {
    minReputation: 0.8,
    preferredAgents: ['agent-id-1', 'agent-id-2'],
    requiredCapabilities: ['jupiter', 'drift']
  }
};

This SDK reference provides comprehensive coverage of VORT's programmatic interface. For integration examples and best practices, see the Integration Guide. For proof verification details, see the Proof Verification guide.