> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ondb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Task Management

> Async operations with ticket-based status tracking

OnDB supports async operations with ticket-based status tracking for long-running operations.

## Task Status Flow

```mermaid theme={null}
stateDiagram-v2
    [*] --> Pending
    Pending --> PaymentBroadcast
    PaymentBroadcast --> PaymentConfirming
    PaymentConfirming --> PaymentConfirmed
    PaymentConfirmed --> StoringData
    StoringData --> Completed
    StoringData --> Failed
    PaymentConfirming --> Failed
```

## Getting Task Tickets

When `waitForConfirmation` is `false`, operations return immediately with a task ticket:

```typescript TypeScript theme={null}
const response = await client.store(
  { collection: 'large_dataset', data: largeData },
  paymentCallback,
  false // Don't wait for confirmation
);

console.log('Task ticket:', response.ticket_id);
```

## Check Task Status

```typescript TypeScript theme={null}
const status = await client.getTaskStatus(ticketId);
console.log('Current status:', status.status);
```

## Wait for Task Completion

```typescript TypeScript theme={null}
// Wait for task to complete
const task = await client.waitForTaskCompletion(ticketId);
console.log('Task completed:', task.status);

// With custom poll interval and max wait time
const task = await client.waitForTaskCompletion(
  ticketId,
  2000,    // Poll every 2 seconds
  300000   // Max wait 5 minutes
);
```

## Task Status Types

| Status              | Description                      |
| ------------------- | -------------------------------- |
| `Pending`           | Task queued, waiting to start    |
| `PaymentBroadcast`  | Payment transaction sent         |
| `PaymentConfirming` | Waiting for payment confirmation |
| `PaymentConfirmed`  | Payment confirmed on-chain       |
| `StoringData`       | Writing data to blockchain       |
| `Completed`         | Task finished successfully       |
| `Failed`            | Task failed with error           |

## Polling Pattern

```typescript TypeScript theme={null}
async function pollTaskStatus(ticketId: string) {
  const maxAttempts = 30;
  const pollInterval = 2000;

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const status = await client.getTaskStatus(ticketId);

    if (status.status === 'Completed') {
      return { success: true, data: status };
    }

    if (typeof status.status === 'object' && 'Failed' in status.status) {
      return { success: false, error: status.status.Failed.error };
    }

    console.log(`Attempt ${attempt + 1}: ${status.status}`);
    await new Promise(resolve => setTimeout(resolve, pollInterval));
  }

  return { success: false, error: 'Timeout waiting for task completion' };
}
```

## Next Steps

<CardGroup cols={2}>
  <Card title="Transaction Tracking" icon="clock" href="/advanced/transaction-tracking">
    Event-based transaction monitoring
  </Card>

  <Card title="Error Handling" icon="triangle-exclamation" href="/advanced/error-handling">
    Handle errors gracefully
  </Card>
</CardGroup>