Implement new Error handling package about fuels-ts

[arboleya]

Let's not worry about code ownership; it will only worsen the problem.

Having everything condensed is easier to maintain.

Error handling can be simple.

---

Single package:

packages/errors
└── src
    ├── error-codes.ts
    └── index.ts

Single enum:

export enum ErrorCodes {
  // provider
  INVALID_URL = 'invalid-url',

  // wallet
  INSUFFICIENT_BALANCE = 'insufficient-balance',

  // coder
  // ...
}

Single class:

import { ErrorCodes } from './error-codes';

export * from './error-codes';

export class FuelError extends Error {
  static readonly CODES = ErrorCodes;
  static parse(e: unknown) {
    return e as FuelError;
  }

  code: ErrorCodes;
  constructor(code: ErrorCodes, message: string) {
    super(message);
    this.code = code;
  }
}

---

Internal usage:

import { FuelError, ErrorCodes } from '@fuel-ts/error';

export function singleImport() {
  throw new FuelError(FuelError.CODES.INVALID_URL, 'Invalid URL');
}

export function multipleImports() {
  throw new FuelError(ErrorCodes.INVALID_URL, 'Invalid URL');
}

---

External usage:

import { FuelError, Provider } from 'fuels';

type Locale = 'PT_BR' | 'BS_BA';

const currentLocale: Locale = 'PT_BR';

const i18nDict = {
  PT_BR: {
    [FuelError.CODES.INVALID_URL]: 'Endereço inválido',
    [FuelError.CODES.INSUFFICIENT_BALANCE]: 'Saldo insuficiente',
  },
  BS_BA: {
    [FuelError.CODES.INVALID_URL]: 'Nevažeća adresa',
    [FuelError.CODES.INSUFFICIENT_BALANCE]: 'Nedovoljan balans',
  },
};

function translateError(e: unknown) {
  const { code } = FuelError.parse(e)
  return i18nDict[currentLocale][code];
}

(function main() {
  try {
    const p = new Provider('0004:tƨoʜlɒɔol//:qttʜ');
    console.log(p);
  } catch (e) {
    const prettyError = translateError(e);
    console.log({ prettyError });
  }
})();

[nedsalk]

A possible solution for error code ownership is to make the SdkError abstract and have each package define their own package error:

// sdk-error.ts

export abstract class SdkError<T extends string> extends Error {
  code: T;
  constructor(code: T, message?: string) {
    super(message);
    this.code = code;
  }
}

// abi-coder/abi-coder-error.ts

type ErrorCode = 'InvalidData' | 'TypeNotFoundOnAbi';

export class AbiCoderError extends SdkError<ErrorCode> {
  constructor(code: ErrorCode, additional_message?: string) {
    super(code, additional_message);

    this.name = 'SdkError/AbiCoder';
  }
}

And the same in other packages (ProviderError, ContractError, ...).

This would strike a middle line between excessive stub error classes like TransactionNotFoundError and having one class to rule them all - SdkError - that knows more than it should know.