interface StepStatusPayload {
  /** Step identifier */
  stepId: string;
  /** Type of step */
  step: StepType;
  /** Current status */
  status: 'pending' | 'active' | 'completed' | 'failed';
  /** Transaction hash (if submitted) */
  txHash: string | null;
  /** Error (if failed) */
  error: Error | null;
  /** Timestamp of last update */
  timestamp: number;
}

const result = await mina.execute({
  quote,
  signer,
  onStepChange: (payload: StepStatusPayload) => {
    console.log(`Step ${payload.stepId}: ${payload.status}`);

    if (payload.status === 'active') {
      console.log('Transaction submitted:', payload.txHash);
    }

    if (payload.status === 'failed') {
      console.error('Step failed:', payload.error?.message);
    }
  },
});

interface TransactionStatusPayload {
  /** Overall status */
  status: 'pending' | 'in_progress' | 'completed' | 'failed';
  /** Substatus for detailed state */
  substatus: string;
  /** Current step index (1-based for UI display) */
  currentStep: number;
  /** Total number of steps */
  totalSteps: number;
  /** Input amount */
  fromAmount: string;
  /** Output amount (or expected) */
  toAmount: string | null;
  /** Bridge transaction hash */
  txHash: string;
  /** Receiving transaction hash on destination chain */
  receivingTxHash: string | null;
  /** Progress percentage (0-100) */
  progress: number;
  /** Estimated time remaining in seconds */
  estimatedTime: number;
}

const result = await mina.execute({
  quote,
  signer,
  onStatusChange: (payload: TransactionStatusPayload) => {
    // Update progress bar
    setProgress(payload.progress);

    // Show current step
    setStatusText(`Step ${payload.currentStep} of ${payload.totalSteps}`);

    // Display detailed status
    console.log('Substatus:', payload.substatus);

    if (payload.receivingTxHash) {
      console.log('Receiving tx:', payload.receivingTxHash);
    }
  },
});

type ExecutionStatusType =
  | 'idle'
  | 'approving'
  | 'approved'
  | 'executing'
  | 'bridging'
  | 'completed'
  | 'failed';

idle -> approving -> approved -> executing -> bridging -> completed
                                    |            |
                                    v            v
                                 failed       failed

type StepType = 'approval' | 'swap' | 'bridge' | 'deposit';

interface StepStatus {
  /** Step ID */
  stepId: string;
  /** Step type */
  stepType?: StepType;
  /** Current status */
  status: 'pending' | 'executing' | 'completed' | 'failed';
  /** Transaction hash (if submitted) */
  txHash?: string;
  /** Error message (if failed) */
  error?: string;
  /** Timestamp of last update */
  updatedAt: number;
}

/** Callback type for step changes */
type OnStepChange = (stepStatus: StepStatusPayload) => void;

/** Callback type for overall status changes */
type OnStatusChange = (status: TransactionStatusPayload) => void;

import type {
  OnStepChange,
  OnStatusChange,
  StepStatusPayload,
  TransactionStatusPayload
} from '@mina-bridge/sdk';

const handleStepChange: OnStepChange = (step: StepStatusPayload) => {
  switch (step.status) {
    case 'pending':
      console.log(`Waiting for ${step.step}...`);
      break;
    case 'active':
      console.log(`${step.step} in progress: ${step.txHash}`);
      break;
    case 'completed':
      console.log(`${step.step} completed`);
      break;
    case 'failed':
      console.error(`${step.step} failed: ${step.error?.message}`);
      break;
  }
};

const handleStatusChange: OnStatusChange = (status: TransactionStatusPayload) => {
  updateUI({
    progress: status.progress,
    currentStep: status.currentStep,
    totalSteps: status.totalSteps,
    message: status.substatus,
  });
};

await mina.execute({
  quote,
  signer,
  onStepChange: handleStepChange,
  onStatusChange: handleStatusChange,
});