Error handling

import { errorForCode, errorForName, type ProgramErrorInfo } from '@rekt/1000x';

export function explain(code: number): string {
  // null for a code this program cannot produce — do not assume every custom code is ours.
  const info: ProgramErrorInfo | null = errorForCode(code);
  if (!info) return `custom program error ${code} did not come from this program`;

  return [
    `${info.name} (${info.code})`,
    info.msg ?? '',
    `Cause: ${info.cause}`,
    `Do this: ${info.fix}`,
    `Retry? ${info.retryable}`,
  ].join('\n');
}

export const byName = errorForName('NoFreshPrice');

import { ProgramRefusal } from '@rekt/1000x';

export async function withRetry<T>(action: () => Promise<T>, attempts = 3): Promise<T> {
  for (let i = 0; ; i += 1) {
    try {
      return await action();
    } catch (e) {
      if (!(e instanceof ProgramRefusal)) throw e;

      switch (e.retryable) {
        case 'never':
          // The request is wrong. Retrying is a loop; surface the fix instead.
          throw new Error(`${e.info.name}: ${e.info.fix}`);
        case 'after-governance':
          // Only the config authority clears it, and nothing changes on its own. Do not retry on a
          // timer: surface the fix, which names the instruction and the key, and alert an operator.
          throw new Error(`${e.info.name}: ${e.info.fix}`);
        case 'after-state-changes':
        case 'immediately':
          break;
      }

      if (i >= attempts) throw e;

      // `immediately` is a slot away; `after-state-changes` deserves real backoff. A slot is not
      // a constant — `config.params.slotMs` is governed (`0` reads as 400) — so read it if the
      // margin matters to you.
      const waitMs = e.retryable === 'immediately' ? 400 : 2_000 * (i + 1);
      await new Promise((r) => setTimeout(r, waitMs));
    }
  }
}