Function explicitlyCastable

packages/utils/src/types.ts:61–109

(from?: Type, to?: Type)

};

export function explicitlyCastable(from?: Type, to?: Type): boolean {
  if (!from || !to) return false;

  // Tuples can't be cast
  if (from instanceof TupleType || to instanceof TupleType) return false;

  // Arrays can be cast if their elements can be cast (don't think this is actually used ever)
  if (from instanceof ArrayType && to instanceof ArrayType) {
    return explicitlyCastable(from.elementType, to.elementType);
  }

  // Can't cast between Array and non-Array
  if (from instanceof ArrayType || to instanceof ArrayType) return false;

  if (to instanceof BytesType) {
    // Can't cast bool to bytes
    if (from === PrimitiveType.BOOL) return false;
    // Can cast int to any size bytes
    if (from === PrimitiveType.INT) return true;

    // Can freely cast to unbounded bytes
    if (!to.bound) return true;

    if (from instanceof BytesType) {
      // Can freely cast from unbounded bytes
      if (!from.bound) return true;
      // Can only cast bounded bytes to bounded bytes if bounds are equal
      return from.bound === to.bound;
    }

    // Cannot cast other primitive types directly to bounded bytes types
    return false;
  }

  if (from instanceof BytesType) {
    // Can cast any bytes to int
    if (to === PrimitiveType.INT) return true;
    // Can't cast bytes to bool or string
    if (to === PrimitiveType.BOOL) return false;
    if (to === PrimitiveType.STRING) return false;
    // Can cast any bytes to pubkey, sig, datasig
    if (to === PrimitiveType.PUBKEY) return true;
    if (to === PrimitiveType.SIG) return true;
    if (to === PrimitiveType.DATASIG) return true;
    return true;
  }

  return ExplicitlyCastableTo[from].includes(to);
}

export function implicitlyCastable(actual?: Type, expected?: Type): boolean {
  if (!actual || !expected) return false;