@global-torque/invest-core 0.2.2

package/src/helpers/formatters/formatToDate.ts

@@ -0,0 +1,47 @@
+const BASE_OPTIONS = {
+  year: 'numeric',
+  month: 'numeric',
+  day: 'numeric',
+} as const;
+
+const HOURS_OPTIONS = {
+  ...BASE_OPTIONS,
+  hour: 'numeric',
+  minute: 'numeric',
+} as const;
+
+const ONLY_HOURS_OPTIONS = {
+  hour: 'numeric',
+  minute: 'numeric',
+} as const;
+
+export const formatToDate = (ISOString: string, withHours = false) => (
+  new Intl.DateTimeFormat('en-US', withHours ? HOURS_OPTIONS : BASE_OPTIONS)
+    .format(new Date(ISOString))
+);
+
+export const formatToFullDate = (ISOString: string) => (
+  new Intl.DateTimeFormat('en-US', BASE_OPTIONS)
+    .format(new Date(ISOString))
+);
+
+export const formatToTime = (ISOString: string) => (
+  new Intl.DateTimeFormat('en-US', ONLY_HOURS_OPTIONS)
+    .format(new Date(ISOString))
+);
+
+export const formatToShortMonth = (ISOString: string) => (
+  new Intl.DateTimeFormat('en-US', { month: 'short' }).format(new Date(ISOString))
+);
+
+export function formatDateToShortMonthDateYear(dateInput: Date | string): string {
+  const date = new Date(dateInput);
+  const options: Intl.DateTimeFormatOptions = {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  };
+
+  const formatted = date.toLocaleDateString('en-US', options);
+  return formatted.replace(/^[A-Z]/, (m) => m); // lowercase the first letter of the month
+}

package/src/helpers/formatters/formatToNumber.ts

@@ -0,0 +1,39 @@
+import trimEnd from 'lodash/trimEnd.js';
+
+/**
+ * when round === Infinity -> 1000.0000123 convert to 1,000.000123
+ * when round === true     -> 1000.0000123 convert to 1,000.0001
+ * when round === false    -> 1000.0000123 convert to 1,000
+ */
+export const formatToNumber = (
+  number: number | `${number}`,
+  round: boolean | typeof Infinity = false,
+  compact = false,
+) => {
+  const numberString = typeof number === 'number' && number < 1e-6
+    ? number.toFixed(18)
+    : number.toString();
+  let minimumFractionDigits = round === Infinity
+    ? numberString.split('.')[1]?.length
+    : round ? 2 : undefined;
+
+  if (minimumFractionDigits) {
+    minimumFractionDigits = minimumFractionDigits > 18 ? 18 : minimumFractionDigits;
+  }
+
+  const result = Intl.NumberFormat('en-US', {
+    minimumFractionDigits,
+    notation: compact ? 'compact' : undefined,
+  }).format(+number);
+
+  // for round === Infinity do not convert xxx.00000266666666 -> xxx.0000026700000
+  if (!compact && round === Infinity) {
+    let second = numberString.split('.')[1];
+    second = trimEnd(trimEnd(second, '0'), '.');
+    if (!second) return result;
+
+    return `${result.split('.')[0]}.${second}`;
+  }
+
+  return result;
+};

package/src/helpers/formatters/formatToPhone.ts

@@ -0,0 +1,13 @@
+export function formatPhoneNumber(input: string | number): string {
+  const digits = input.toString().replace(/\D/g, '');
+
+  if (digits.length !== 11 || !digits.startsWith('1')) {
+    return '';
+  }
+
+  const areaCode = digits.slice(1, 4);
+  const centralOfficeCode = digits.slice(4, 7);
+  const lineNumber = digits.slice(7, 11);
+
+  return `+1 (${areaCode}) ${centralOfficeCode} - ${lineNumber}`;
+}

package/src/helpers/general.ts

@@ -0,0 +1,164 @@
+import lodashIsEmpty from 'lodash/isEmpty.js';
+import startCase from 'lodash/startCase.js';
+import toLower from 'lodash/toLower.js';
+import unionBy from 'lodash/unionBy.js';
+import kebabCase from 'lodash/kebabCase.js';
+
+export function isEmpty(obj: object) {
+  return lodashIsEmpty(obj);
+}
+
+export function formatPhoneNumber(phoneNumber: string | undefined): string | undefined {
+  if (!phoneNumber) return undefined;
+  // Remove all non-digit characters from the input string
+  let cleaned: string = phoneNumber.replace(/\D/g, '');
+  // Extract the country code (if present)
+  let countryCode: string = '';
+  if (cleaned.length > 10) {
+    countryCode = `+${cleaned.slice(0, cleaned.length - 10)} `;
+    // Remove country code from the cleaned string
+    cleaned = cleaned.slice(-10);
+  }
+  // Extract the area code and the rest of the number
+  const areaCode: string = cleaned.slice(0, 3);
+  const middlePart: string = cleaned.slice(3, 6);
+  const lastPart: string = cleaned.slice(6);
+
+  // Format the phone number parts into the desired format
+  const formattedPhoneNumber: string = `${countryCode}(${areaCode}) ${middlePart}-${lastPart}`;
+
+  return formattedPhoneNumber;
+}
+
+export function booleanFormatToString(value: boolean | undefined) {
+  if (value === undefined) return undefined;
+  if (value) return 'Yes';
+  return 'No';
+}
+
+export function checkObjectAndDeleteNotRequiredFields(
+  defaultParameters: string[],
+  requiredFields: string[],
+  obj: Record<string, string>,
+) {
+  return Object.keys(obj).reduce<Record<string, string>>((acc, key) => {
+    if (defaultParameters.includes(key)) {
+      acc[key] = obj[key]; // Set the new value for 'type'
+    } else if (requiredFields.includes(obj[key])) {
+      acc[key] = obj[key];
+    } else {
+      // If property value is not in requiredEmployment.value, delete the property
+      delete acc[key];
+    }
+    return acc;
+  }, {});
+}
+
+export function urlize(input: string): string {
+  return kebabCase(input);
+}
+
+export function getUniqueCapitalizedTags(
+  items: readonly { tags?: readonly string[] | null }[],
+): string[] {
+  if (!items || items.length === 0) return [];
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  items.forEach((item) => {
+    const tags = (item.tags || []).filter(Boolean) as string[];
+    tags.forEach((rawTag) => {
+      const trimmed = rawTag.trim();
+      if (!trimmed) return;
+      const key = toLower(trimmed);
+      if (seen.has(key)) return;
+      seen.add(key);
+      // Preserve common separators like '/' while capitalizing parts
+      if (key.includes('/')) {
+        const formatted = key.split('/').map((part) => startCase(part)).join('/');
+        result.push(formatted);
+      } else {
+        result.push(startCase(key));
+      }
+    });
+  });
+
+  return result;
+}
+
+export function combineTags(
+  tagsArray1: readonly string[],
+  tagsArray2: readonly string[],
+): string[] {
+  return unionBy(tagsArray1, tagsArray2, (t) => toLower(t));
+}
+
+export function filterItemsByTag<T extends { tags?: readonly string[] }>(
+  items: readonly T[],
+  activeTag: string,
+): T[] {
+  if (activeTag !== '') {
+    const normalize = (s: string) => kebabCase(toLower(s.trim()));
+    const active = normalize(activeTag);
+    return items.filter((item) => (item.tags || [])
+      .some((tag) => normalize(tag) === active));
+  }
+  return [...items];
+}
+// Define interfaces for the expected object structure
+interface EntityValue {
+  [key: string]: any;
+}
+
+interface TopLevelValue {
+  entities: Record<string, EntityValue>;
+}
+
+interface MergedObject {
+  [key: string]: TopLevelValue;
+}
+
+export function mergeObjects(obj1: any, obj2: any): MergedObject {
+  if (!obj1 || !obj2) return {};
+  const merged = { ...obj1 };
+
+  Object.entries(obj2).forEach(([topKey, topValue]) => {
+    // Ensure topValue is an object with entities property
+    if (topValue && typeof topValue === 'object' && 'entities' in topValue) {
+      merged[topKey] = merged[topKey] || { entities: {} };
+      merged[topKey].entities = merged[topKey].entities || {};
+
+      // Ensure topValue.entities is an object before iterating
+      if (typeof topValue.entities === 'object' && topValue.entities !== null) {
+        Object.entries(topValue.entities).forEach(([entityKey, entityValue]) => {
+          // Ensure entityValue is an object before spreading
+          if (entityValue && typeof entityValue === 'object') {
+            merged[topKey].entities[entityKey] = {
+              ...merged[topKey].entities[entityKey],
+              ...entityValue,
+            };
+          } else {
+            // If entityValue is not an object, just assign it directly
+            merged[topKey].entities[entityKey] = entityValue;
+          }
+        });
+      }
+    }
+  });
+
+  return merged;
+}
+
+export const transformedArray = (mergedObj: MergedObject) => {
+  if (!mergedObj || Object.keys(mergedObj).length === 0) return [];
+  return (Object.keys(mergedObj)?.map((topKey) => {
+    if (!mergedObj[topKey]?.entities) return [];
+    return (
+      Object.keys(mergedObj[topKey]?.entities).map((entityKey) => ({
+        name: mergedObj[topKey].entities[entityKey].original_filename || mergedObj[topKey].entities[entityKey].filename,
+        'object-type': topKey, // This will be the top-level key, e.g., companyA
+        updated_at: mergedObj[topKey].entities[entityKey].updated_at,
+        url: mergedObj[topKey].entities[entityKey].url,
+      })));
+  }).flat());
+};

package/src/helpers/model.ts

@@ -0,0 +1,87 @@
+import { JSONSchemaType } from 'ajv/dist/types/json-schema';
+import cloneDeep from 'lodash/cloneDeep.js';
+import defaults from 'lodash/defaults.js';
+import pick from 'lodash/pick.js';
+import { capitalizeFirstLetter } from './text';
+
+export function populateModel<T extends object>(source: Partial<T>, defaultsObj: T): T {
+  // ensure only keys from defaults are preserved; then fill missing via defaults
+  const picked = pick(source as Record<string, any>, Object.keys(defaultsObj)) as Partial<T>;
+  return defaults({} as T, picked, defaultsObj);
+}
+
+// Function to initialize properties recursively
+const initializeProperties = (properties: Record<string, any>): Record<string, any> => {
+  // Default type initializers for known types
+  const defaultValueMap: Record<string, any> = {
+    string: '',
+    number: 0,
+    object: {},
+    boolean: false,
+  };
+  return Object.keys(properties).reduce((acc, key) => {
+    const prop = properties[key];
+
+    // Handle nested objects
+    if (prop.type === 'object' && prop.properties) {
+      acc[key] = initializeProperties(prop.properties);
+    } else {
+      // Handle basic types
+      acc[key] = defaultValueMap[prop.type] ?? null;
+    }
+
+    return acc;
+  }, {} as Record<string, any>);
+};
+
+export const createFormModel = <T>(schema: JSONSchemaType<T>): Record<string, any> => {
+  if (!schema || !schema.$ref) return {} as Record<string, any>;
+  // clone deep to ensure we don't mix schemas
+  const newSchema = cloneDeep(schema);
+  // get path
+  const path = newSchema.$ref?.replace('#/', '')?.split('/') || [];
+
+  // get object from path
+  let mainDataObject = newSchema;
+  for (const key of path) { // TODO reqrite as array iteration
+    if (key !== '') mainDataObject = mainDataObject[key];
+  }
+  // Initialize form model based on the schema's root definition
+  const rootDefinition = mainDataObject.properties;
+  return initializeProperties(rootDefinition);
+};
+
+export const getOptions = (
+  fieldPath: string,
+  schemaObject: { value: any }, // Pass schemaObject as a prop
+): { value: string; name: string }[] => {
+  const optionsCache = new Map<string, { value: string; name: string }[]>();
+  // Check if options for this field are already cached
+  if (optionsCache.has(fieldPath)) {
+    return optionsCache.get(fieldPath) || [];
+  }
+
+  // Split the fieldPath into parts and traverse the schema object
+  const target = fieldPath.split('.').reduce((acc, part) => acc?.[part], schemaObject.value);
+
+  // If the target field doesn't exist, return empty options
+  if (!target) {
+    optionsCache.set(fieldPath, []);
+    return [];
+  }
+
+  // Extract the options (enum and enumNames) from the target field
+  const values = target?.enum || [];
+  const names = target?.enumNames || [];
+
+  // Map the values and names to an array of objects { value, name }
+  const options = values.map((value: string, index: number) => ({
+    value,
+    name: capitalizeFirstLetter(names[index] || value), // Default to the value itself if no enumNames
+  }));
+
+  // Cache the options for future use
+  optionsCache.set(fieldPath, options);
+
+  return options;
+};

package/src/helpers/numberFormatter.ts

@@ -0,0 +1,4 @@
+export function numberFormatter(value: number | string) {
+  return +value.toString().replace(/[^0-9.]/g, '');
+}
+

package/src/helpers/text.ts

@@ -0,0 +1,51 @@
+export const capitalizeFirstLetter = (str: string) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export const stripMarkdown = (markdown: string): string => {
+  // Replace bold text with plain text
+  markdown = markdown.replace(/\*\*(.+?)\*\*/g, '');
+  markdown = markdown.replace(/__(.+?)__/g, '');
+
+  // Replace italicized text with plain text
+  markdown = markdown.replace(/_(.+?)_/g, '');
+  markdown = markdown.replace(/\*(.+?)\*/g, '');
+
+  // Replace strikethrough text with plain text
+  markdown = markdown.replace(/~~(.+?)~~/g, '');
+
+  // Replace inline code blocks with plain text
+  markdown = markdown.replace(/`(.+?)`/g, '');
+
+  // Replace code blocks with plain text (multiline)
+  markdown = markdown.replace(/```[\s\S]*?```/g, '');
+
+  // Keep the text inside links but remove the URL
+  markdown = markdown.replace(/\[(.+?)\]\((.+?)\)/g, '$1');
+
+  // Remove images
+  markdown = markdown.replace(/!\[(.+?)\]\((.+?)\)/g, '');
+
+  // Remove headings
+  markdown = markdown.replace(/^#+\s+(.+?)\s*$/gm, '');
+  markdown = markdown.replace(/^\s*=+\s*$/gm, '');
+  markdown = markdown.replace(/^\s*-+\s*$/gm, '');
+
+  // Remove blockquotes
+  markdown = markdown.replace(/^\s*>\s+(.+?)\s*$/gm, '');
+
+  // Remove lists
+  markdown = markdown.replace(/^\s*[*+-]\s+(.+?)\s*$/gm, '');
+  markdown = markdown.replace(/^\s*\d+\.\s+(.+?)\s*$/gm, '');
+
+  // Remove horizontal lines
+  markdown = markdown.replace(/^\s*[-*_]{3,}\s*$/gm, '');
+
+  return markdown;
+};
+
+export function stripHtml(html: string) {
+  return html.replace(/(<([^>]+)>)/gi, '');
+}
+
+export function stripHtmlAndMarkdown(html: string) {
+  return stripMarkdown(stripHtml(html));
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+export * from './app/config.ts';
+export * from './analytics/analyticsBody.ts';
+export * from './decimal/canonicalDecimal.ts';
+export * from './evm/walletInfo.ts';
+export * from './formatting/dateTime.ts';
+export * from './filer/publicImage.ts';
+export * from './filer/documentFormatter.ts';
+export * from './notifications/shareFields.ts';
+export * from './formatting/display.ts';
+export * from './investment/status.ts';
+export * from './investment/rawAmount.ts';
+export * from './kyc/kycAlert.ts';
+export * from './kyc/status.ts';
+export * from './kyc/thirdPartyScreen.ts';
+export * from './offer/metrics.ts';
+export * from './onboarding/intents.ts';
+export * from './profiles/formatting.ts';
+export * from './repository/formatterCache.ts';
+export * from './wallet/auth.ts';
+export * from './wallet/operationPresentation.ts';
+export * from './wallet/setupError.ts';
+export * from './form-validation/index.ts';

package/src/investment/__tests__/status.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import {
+  FundingTypes,
+  InvestFundingStatuses,
+  InvestmentStatuses,
+} from '@global-torque/domain-types/investmentTypes';
+import {
+  isInvestmentActiveStatus,
+  isInvestmentCancelledStatus,
+  isInvestmentCompletedStatus,
+  isInvestmentFundingClickable,
+  isInvestmentFundingTypeWire,
+  isInvestmentPendingFundingStatus,
+} from '../status.ts';
+
+describe('investment status helpers', () => {
+  it('classifies funding type and investment lifecycle statuses', () => {
+    expect(isInvestmentFundingTypeWire(FundingTypes.wire)).toBe(true);
+    expect(isInvestmentFundingTypeWire(FundingTypes.wallet)).toBe(false);
+    expect(isInvestmentActiveStatus(InvestmentStatuses.confirmed)).toBe(true);
+    expect(isInvestmentActiveStatus(InvestmentStatuses.legally_confirmed)).toBe(true);
+    expect(isInvestmentCompletedStatus(InvestmentStatuses.closed_successfully)).toBe(true);
+    expect(isInvestmentCancelledStatus(InvestmentStatuses.cancelled_after_investment)).toBe(true);
+  });
+
+  it('classifies pending funding statuses', () => {
+    expect(isInvestmentPendingFundingStatus(InvestFundingStatuses.in_progress)).toBe(true);
+    expect(isInvestmentPendingFundingStatus(InvestFundingStatuses.initialize)).toBe(true);
+    expect(isInvestmentPendingFundingStatus(InvestFundingStatuses.settled)).toBe(false);
+  });
+
+  it('preserves existing funding clickability rules', () => {
+    expect(isInvestmentFundingClickable({
+      fundingType: FundingTypes.wire,
+      fundingStatus: InvestFundingStatuses.none,
+      status: InvestmentStatuses.confirmed,
+    })).toBe(true);
+    expect(isInvestmentFundingClickable({
+      fundingType: FundingTypes.wallet,
+      fundingStatus: InvestFundingStatuses.settled,
+      status: InvestmentStatuses.legally_confirmed,
+    })).toBe(true);
+    expect(isInvestmentFundingClickable({
+      fundingType: FundingTypes.wallet,
+      fundingStatus: InvestFundingStatuses.none,
+      status: InvestmentStatuses.legally_confirmed,
+    })).toBe(false);
+    expect(isInvestmentFundingClickable({
+      fundingType: FundingTypes.ach,
+      fundingStatus: InvestFundingStatuses.settled,
+      status: InvestmentStatuses.confirmed,
+    })).toBe(false);
+    expect(isInvestmentFundingClickable({
+      fundingType: FundingTypes.wire,
+      fundingStatus: InvestFundingStatuses.creation_error,
+      status: InvestmentStatuses.confirmed,
+    })).toBe(false);
+  });
+});

package/src/investment/rawAmount.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import {
+  compareRawAmounts,
+  decimalAmountToRaw,
+  formatRawAmount,
+  formatSignedRawAmount,
+} from './rawAmount.ts';
+
+describe('raw token amount helpers', () => {
+  it('converts fractional shares without floating-point arithmetic', () => {
+    expect(decimalAmountToRaw('0.25', 18)).toBe('250000000000000000');
+    expect(decimalAmountToRaw('125.5000000000000000001', 18)).toBeNull();
+    expect(decimalAmountToRaw('1e3', 18)).toBeNull();
+  });
+
+  it('compares and formats exact integer raw values', () => {
+    expect(compareRawAmounts('250000000000000000', '1000000000000000000')).toBe(-1);
+    expect(compareRawAmounts('01', '1')).toBeNull();
+    expect(formatRawAmount('250000000000000000', 18)).toBe('0.25');
+    expect(formatRawAmount('6250000', 6)).toBe('6.25');
+    expect(formatSignedRawAmount('-2000000', 6)).toBe('-2');
+  });
+});

package/src/investment/rawAmount.ts

@@ -0,0 +1,81 @@
+const RAW_AMOUNT = /^(?:0|[1-9]\d*)$/u;
+const DECIMAL_AMOUNT = /^(?:0|[1-9]\d*)(?:\.(\d+))?$/u;
+
+export const normalizeRawAmount = (value: string): string | null => {
+  const normalized = value.trim();
+  if (!RAW_AMOUNT.test(normalized)) return null;
+  return BigInt(normalized).toString();
+};
+
+export const decimalAmountToRaw = (
+  value: string,
+  decimals: number,
+): string | null => {
+  if (!Number.isSafeInteger(decimals) || decimals < 0) return null;
+  const normalized = value.trim();
+  const match = DECIMAL_AMOUNT.exec(normalized);
+  if (!match) return null;
+
+  const fractional = match[1] ?? '';
+  if (fractional.length > decimals) return null;
+
+  const whole = normalized.split('.')[0] ?? '0';
+  const paddedFractional = fractional.padEnd(decimals, '0');
+  return normalizeRawAmount(`${whole}${paddedFractional}`.replace(/^0+(?=\d)/u, ''));
+};
+
+export const compareRawAmounts = (left: string, right: string): number | null => {
+  const normalizedLeft = normalizeRawAmount(left);
+  const normalizedRight = normalizeRawAmount(right);
+  if (normalizedLeft === null || normalizedRight === null) return null;
+
+  const leftValue = BigInt(normalizedLeft);
+  const rightValue = BigInt(normalizedRight);
+  if (leftValue === rightValue) return 0;
+  return leftValue < rightValue ? -1 : 1;
+};
+
+export const formatRawAmount = (
+  value: string,
+  decimals: number,
+  options: {
+    maximumFractionDigits?: number;
+    trimTrailingZeros?: boolean;
+  } = {},
+): string => {
+  const normalized = normalizeRawAmount(value);
+  if (normalized === null || !Number.isSafeInteger(decimals) || decimals < 0) {
+    return '';
+  }
+
+  const padded = normalized.padStart(decimals + 1, '0');
+  const whole = decimals === 0 ? padded : padded.slice(0, -decimals);
+  let fractional = decimals === 0 ? '' : padded.slice(-decimals);
+  const maximumFractionDigits = options.maximumFractionDigits ?? decimals;
+  if (Number.isSafeInteger(maximumFractionDigits) && maximumFractionDigits >= 0) {
+    fractional = fractional.slice(0, maximumFractionDigits);
+  }
+  if (options.trimTrailingZeros !== false) {
+    fractional = fractional.replace(/0+$/u, '');
+  }
+  return fractional ? `${whole}.${fractional}` : whole;
+};
+
+export const formatSignedRawAmount = (
+  value: string,
+  decimals: number,
+  options: {
+    maximumFractionDigits?: number;
+    trimTrailingZeros?: boolean;
+  } = {},
+): string => {
+  const normalized = value.trim();
+  const negative = normalized.startsWith('-');
+  const formatted = formatRawAmount(
+    negative ? normalized.slice(1) : normalized,
+    decimals,
+    options,
+  );
+  if (!formatted) return '';
+  return negative && formatted !== '0' ? `-${formatted}` : formatted;
+};

package/src/investment/status.ts

@@ -0,0 +1,56 @@
+import {
+  FundingTypes,
+  InvestFundingStatuses,
+  InvestmentStatuses,
+} from '@global-torque/domain-types/investmentTypes';
+
+export type InvestmentFundingClickabilityInput = {
+  fundingType?: FundingTypes | string | null;
+  fundingStatus?: InvestFundingStatuses | string | null;
+  status?: InvestmentStatuses | string | null;
+};
+
+export const isInvestmentFundingTypeWire = (
+  fundingType?: FundingTypes | string | null,
+): boolean => fundingType === FundingTypes.wire;
+
+export const isInvestmentActiveStatus = (
+  status?: InvestmentStatuses | string | null,
+): boolean => (
+  status === InvestmentStatuses.confirmed
+  || status === InvestmentStatuses.legally_confirmed
+);
+
+export const isInvestmentCompletedStatus = (
+  status?: InvestmentStatuses | string | null,
+): boolean => status === InvestmentStatuses.closed_successfully;
+
+export const isInvestmentCancelledStatus = (
+  status?: InvestmentStatuses | string | null,
+): boolean => status === InvestmentStatuses.cancelled_after_investment;
+
+export const isInvestmentPendingFundingStatus = (
+  fundingStatus?: InvestFundingStatuses | string | null,
+): boolean => (
+  fundingStatus === InvestFundingStatuses.in_progress
+  || fundingStatus === InvestFundingStatuses.initialize
+);
+
+export const isInvestmentFundingClickable = ({
+  fundingType,
+  fundingStatus,
+  status,
+}: InvestmentFundingClickabilityInput): boolean => {
+  const isFundingTypeWire = fundingType === FundingTypes.wire;
+  const isLegallyConfirmed = status === InvestmentStatuses.legally_confirmed;
+  const isConfirmed = status === InvestmentStatuses.confirmed;
+
+  if (!isFundingTypeWire && !isLegallyConfirmed) return false;
+  if (isFundingTypeWire && !isLegallyConfirmed && !isConfirmed) return false;
+  if (!isFundingTypeWire && fundingStatus === InvestFundingStatuses.none) return false;
+  if (fundingStatus === InvestFundingStatuses.creation_error) return false;
+  if (fundingStatus === InvestFundingStatuses.sent_back_pending) return false;
+  if (fundingStatus === InvestFundingStatuses.sent_back_settled) return false;
+
+  return true;
+};