react-native-candle 1.0.1 → 19.0.7-beta

package/src/types.ts

@@ -1,466 +1,449 @@
 import type {
-  ACHDetails,
   ActiveLinkedAccountDetails,
+  AssetAccount as NativeAssetAccount,
+  Counterparty as NativeCounterparty,
+  CounterpartyQuoteRequest as NativeCounterpartyQuoteRequest,
+  LinkedAccount as NativeLinkedAccount,
+  LinkedAccountDetails as NativeLinkedAccountDetails,
+  Trade as NativeTrade,
+  TradeAsset as NativeTradeAsset,
+  TradeAssetQuoteRequest as NativeTradeAssetQuoteRequest,
+  TradeAssetRef as NativeTradeAssetRef,
+  TradeQuote as NativeTradeQuote,
+  TradeQuotesRequest as NativeTradeQuotesRequest,
+  TradeRef as NativeTradeRef,
+  CryptoAccount,
+  CryptoAsset,
+  CryptoAssetQuoteRequest,
+  CryptoAssetRef,
+  EventAsset,
+  EventAssetQuoteRequest,
+  EventAssetRef,
+  FiatAccount,
   FiatAsset,
   FiatAssetQuoteRequest,
   FiatAssetRef,
-  FiatMarketAccountKind,
-  LinkedAccount as _LinkedAccount,
-  MarketAssetQuoteRequest,
-  MarketTradeAsset,
-  MarketTradeAssetRef,
+  InactiveLinkedAccountDetails,
   MerchantCounterparty,
+  MerchantCounterpartyQuoteRequest,
   NothingAsset,
   NothingAssetQuoteRequest,
   NothingAssetRef,
   OtherAsset,
-  OtherAssetRef,
   OtherAssetQuoteRequest,
-  Service,
+  OtherAssetRef,
   ServiceCounterparty,
+  ServiceCounterpartyQuoteRequest,
+  StockAccount,
+  StockAsset,
+  StockAssetQuoteRequest,
+  StockAssetRef,
+  TradeAssetKind,
   TradeState,
-  TransportAccountKind,
+  TransportAccount,
   TransportAsset,
   TransportAssetQuoteRequest,
   TransportAssetRef,
-  UserCounterparty,
-  WireDetails,
-  Trade as _Trade,
-  TradeQuotesRequest as _TradeQuotesRequest,
-  LinkedAccountDetails as _LinkedAccountDetails,
-  AssetAccount as _AssetAccount,
-  TradeRef as _TradeRef,
-  TradeAssetRef as _TradeAssetRef,
-  TradeAsset as _TradeAsset,
-  TradeQuote as _TradeQuote,
-  Counterparty as _Counterparty,
-  CounterpartyQuoteRequest as _CounterpartyQuoteRequest,
-  TradeAssetQuoteRequest as _TradeAssetQuoteRequest,
-  InactiveLinkedAccountDetails,
   UnavailableLinkedAccountDetails,
-  TradeAssetKind,
-  MerchantCounterpartyQuoteRequest,
-  ServiceCounterpartyQuoteRequest,
+  UserCounterparty,
   UserCounterpartyQuoteRequest,
-} from "./specs/RNCandle.nitro";
+} from './specs/RNCandle.nitro'
 
 export type {
   ACHDetails,
-  ActiveLinkedAccountDetails,
-  FiatAsset,
-  FiatAssetQuoteRequest,
-  FiatAssetRef,
-  FiatMarketAccountKind,
-  MarketAssetQuoteRequest,
-  UserCounterpartyQuoteRequest,
-  OtherAssetQuoteRequest,
-  MerchantCounterpartyQuoteRequest,
-  ServiceCounterpartyQuoteRequest,
-  MarketTradeAsset,
-  MarketTradeAssetRef,
-  MerchantCounterparty,
-  NothingAsset,
-  NothingAssetQuoteRequest,
-  NothingAssetRef,
-  OtherAsset,
-  OtherAssetRef,
+  AssetAccountRef,
+  AssetAccountsQuery,
+  FinancialAccountKind,
+  LinkedAccountRef,
+  LinkedAccountStatusRef,
+  PresentationBackground,
+  PresentationStyle,
   Service,
-  ServiceCounterparty,
+  TradeAssetKind,
   TradeState,
-  TransportAccountKind,
-  TransportAsset,
   TradesQuery,
-  TransportAssetQuoteRequest,
-  TransportAssetRef,
-  UserCounterparty,
+  TransportAccountKind,
   WireDetails,
-  PresentationBackground,
-  PresentationStyle,
-  LinkedAccountRef,
-  AssetAccountsQuery,
-  AssetAccountRef,
-  TradeAssetKind,
-  LinkedAccountStatusRef,
-} from "./specs/RNCandle.nitro";
+} from './specs/RNCandle.nitro'
 
-export type TradeQuoteAssetKind =
-  | "nothing"
-  | "transport"
-  | "fiat"
-  | "stock"
-  | "crypto";
+export type TradeQuoteAssetKind = 'nothing' | 'transport' | 'event' | 'fiat' | 'stock' | 'crypto'
 
 // Discriminated unions
 
 export type TradeAssetQuoteRequest =
   | ({
-      assetKind: "nothing";
+      assetKind: 'nothing'
     } & NothingAssetQuoteRequest)
-  | ({ assetKind: "transport" } & TransportAssetQuoteRequest)
-  | ({ assetKind: "fiat" } & FiatAssetQuoteRequest)
-  | ({ assetKind: "stock" | "crypto" } & MarketAssetQuoteRequest)
-  | ({ assetKind: "other" } & OtherAssetQuoteRequest);
+  | ({ assetKind: 'transport' } & TransportAssetQuoteRequest)
+  | ({ assetKind: 'event' } & EventAssetQuoteRequest)
+  | ({ assetKind: 'fiat' } & FiatAssetQuoteRequest)
+  | ({ assetKind: 'stock' } & StockAssetQuoteRequest)
+  | ({ assetKind: 'crypto' } & CryptoAssetQuoteRequest)
+  | ({ assetKind: 'other' } & OtherAssetQuoteRequest)
 
 export type CounterpartyQuoteRequest =
   | ({
-      kind: "user";
+      kind: 'user'
     } & UserCounterpartyQuoteRequest)
-  | ({ kind: "merchant" } & MerchantCounterpartyQuoteRequest)
-  | ({ kind: "service" } & ServiceCounterpartyQuoteRequest);
+  | ({ kind: 'merchant' } & MerchantCounterpartyQuoteRequest)
+  | ({ kind: 'service' } & ServiceCounterpartyQuoteRequest)
 
 export type TradeAsset =
   | ({
-      assetKind: "nothing";
+      assetKind: 'nothing'
     } & NothingAsset)
   | ({
-      assetKind: "other";
+      assetKind: 'other'
     } & OtherAsset)
-  | ({ assetKind: "transport" } & TransportAsset)
-  | ({ assetKind: "fiat" } & FiatAsset)
-  | ({ assetKind: "stock" | "crypto" } & MarketTradeAsset);
+  | ({ assetKind: 'transport' } & TransportAsset)
+  | ({ assetKind: 'event' } & EventAsset)
+  | ({ assetKind: 'fiat' } & FiatAsset)
+  | ({ assetKind: 'stock' } & StockAsset)
+  | ({ assetKind: 'crypto' } & CryptoAsset)
 
 export type Counterparty =
-  | ({ kind: "merchant" } & MerchantCounterparty)
+  | ({ kind: 'merchant' } & MerchantCounterparty)
   | ({
-      kind: "user";
+      kind: 'user'
     } & UserCounterparty)
   | ({
-      kind: "service";
-    } & ServiceCounterparty);
-
-export type AssetAccount = {
-  serviceAccountID: string;
-  nickname: string;
-  linkedAccountID: string;
-  service: Service;
-} & (
-  | {
-      assetKind: "fiat";
-      accountKind: FiatMarketAccountKind;
-      currencyCode: string;
-      balance?: number;
-      ach?: ACHDetails;
-      wire?: WireDetails;
-    }
-  | {
-      assetKind: "stock" | "crypto";
-      accountKind: FiatMarketAccountKind;
-    }
-  | {
-      assetKind: "transport";
-      accountKind: TransportAccountKind;
-    }
-);
+      kind: 'service'
+    } & ServiceCounterparty)
+
+export type AssetAccount =
+  | ({
+      assetKind: 'fiat'
+    } & FiatAccount)
+  | ({
+      assetKind: 'stock'
+    } & StockAccount)
+  | ({
+      assetKind: 'crypto'
+    } & CryptoAccount)
+  | ({
+      assetKind: 'transport'
+    } & TransportAccount)
 
 export type TradeAssetRef =
-  | ({ assetKind: "transport" } & TransportAssetRef)
-  | ({ assetKind: "nothing" } & NothingAssetRef)
-  | ({ assetKind: "other" } & OtherAssetRef)
-  | ({ assetKind: "fiat" } & FiatAssetRef)
-  | ({ assetKind: "stock" | "crypto" } & MarketTradeAssetRef);
+  | ({ assetKind: 'transport' } & TransportAssetRef)
+  | ({ assetKind: 'event' } & EventAssetRef)
+  | ({ assetKind: 'nothing' } & NothingAssetRef)
+  | ({ assetKind: 'other' } & OtherAssetRef)
+  | ({ assetKind: 'fiat' } & FiatAssetRef)
+  | ({ assetKind: 'stock' } & StockAssetRef)
+  | ({ assetKind: 'crypto' } & CryptoAssetRef)
 
 export type LinkedAccountDetails =
-  | ({ state: "active" } & ActiveLinkedAccountDetails)
-  | ({ state: "inactive" } & InactiveLinkedAccountDetails)
-  | ({ state: "unavailable" } & UnavailableLinkedAccountDetails);
+  | ({ state: 'active' } & ActiveLinkedAccountDetails)
+  | ({ state: 'inactive' } & InactiveLinkedAccountDetails)
+  | ({ state: 'unavailable' } & UnavailableLinkedAccountDetails)
 
 // Composite types
 
 export type TradeQuotesRequest<
   GainedAssetKind extends TradeQuoteAssetKind,
-  LostAssetKind extends TradeQuoteAssetKind
+  LostAssetKind extends TradeQuoteAssetKind,
 > = {
-  linkedAccountIDs?: string;
-  gained: TradeAssetQuoteRequest & { assetKind: GainedAssetKind };
-  lost: TradeAssetQuoteRequest & { assetKind: LostAssetKind };
-  counterparty?: CounterpartyQuoteRequest;
-};
+  linkedAccountIDs?: string | undefined
+  gained: TradeAssetQuoteRequest & { assetKind: GainedAssetKind }
+  lost: TradeAssetQuoteRequest & { assetKind: LostAssetKind }
+  counterparty?: CounterpartyQuoteRequest | undefined
+}
 
 export type TradeRef = {
-  lost: TradeAssetRef;
-  gained: TradeAssetRef;
-};
+  lost: TradeAssetRef
+  gained: TradeAssetRef
+}
 
 export type TradeQuote<
   GainedAssetKind extends TradeQuoteAssetKind,
-  LostAssetKind extends TradeQuoteAssetKind
-> = {
-  gained: TradeAsset & { assetKind: GainedAssetKind };
-  lost: TradeAsset & { assetKind: LostAssetKind };
-  counterparty: Counterparty;
-  context: string;
-  expirationDateTime: string;
-};
-
-export type Trade<
-  GainedAssetKind extends TradeAssetKind,
-  LostAssetKind extends TradeAssetKind
+  LostAssetKind extends TradeQuoteAssetKind,
 > = {
-  dateTime: string;
-  state: TradeState;
-  counterparty: Counterparty;
-  gained: TradeAsset & { assetKind: GainedAssetKind };
-  lost: TradeAsset & { assetKind: LostAssetKind };
-};
+  gained: TradeAsset & { assetKind: GainedAssetKind }
+  lost: TradeAsset & { assetKind: LostAssetKind }
+  counterparty: Counterparty
+  context: string
+  expirationDateTime: string
+}
 
-export type LinkedAccount = Omit<_LinkedAccount, "details"> & {
-  details: LinkedAccountDetails;
-};
+export type Trade<GainedAssetKind extends TradeAssetKind, LostAssetKind extends TradeAssetKind> = {
+  dateTime: string
+  state: TradeState
+  counterparty: Counterparty
+  gained: TradeAsset & { assetKind: GainedAssetKind }
+  lost: TradeAsset & { assetKind: LostAssetKind }
+}
+
+export type LinkedAccount = Omit<NativeLinkedAccount, 'details'> & {
+  details: LinkedAccountDetails
+}
 
 // TO discriminated unions
 
-export const toNativeTradeAssetRef = (
-  tradeAssetRef: TradeAssetRef
-): _TradeAssetRef => {
+export const toNativeTradeAssetRef = (tradeAssetRef: TradeAssetRef): NativeTradeAssetRef => {
   switch (tradeAssetRef.assetKind) {
-    case "fiat":
-      return { fiatAssetRef: tradeAssetRef };
-    case "stock":
-    case "crypto":
-      return { marketTradeAssetRef: tradeAssetRef };
-    case "transport":
-      return { transportAssetRef: tradeAssetRef };
-    case "other":
-      return { otherAssetRef: tradeAssetRef };
-    case "nothing":
-      return { nothingAssetRef: tradeAssetRef };
+    case 'fiat': {
+      return { fiatAssetRef: tradeAssetRef }
+    }
+    case 'stock': {
+      return { stockAssetRef: tradeAssetRef }
+    }
+    case 'crypto': {
+      return { cryptoAssetRef: tradeAssetRef }
+    }
+    case 'transport': {
+      return { transportAssetRef: tradeAssetRef }
+    }
+    case 'event': {
+      return { eventAssetRef: tradeAssetRef }
+    }
+    case 'other': {
+      return { otherAssetRef: tradeAssetRef }
+    }
+    case 'nothing': {
+      return { nothingAssetRef: tradeAssetRef }
+    }
   }
-};
+}
 
-export const toNativeTradeAsset = (tradeAsset: TradeAsset): _TradeAsset => {
+export const toNativeTradeAsset = (tradeAsset: TradeAsset): NativeTradeAsset => {
   switch (tradeAsset.assetKind) {
-    case "fiat":
-      return { fiatAsset: tradeAsset };
-    case "stock":
-    case "crypto":
-      return { marketTradeAsset: tradeAsset };
-    case "transport":
-      return { transportAsset: tradeAsset };
-    case "other":
-      return { otherAsset: tradeAsset };
-    case "nothing":
-      return { nothingAsset: tradeAsset };
+    case 'fiat': {
+      return { fiatAsset: tradeAsset }
+    }
+    case 'stock': {
+      return { stockAsset: tradeAsset }
+    }
+    case 'crypto': {
+      return { cryptoAsset: tradeAsset }
+    }
+    case 'transport': {
+      return { transportAsset: tradeAsset }
+    }
+    case 'event': {
+      return { eventAsset: tradeAsset }
+    }
+    case 'other': {
+      return { otherAsset: tradeAsset }
+    }
+    case 'nothing': {
+      return { nothingAsset: tradeAsset }
+    }
   }
-};
+}
 
-export const toNativeCounterparty = (
-  counterparty: Counterparty
-): _Counterparty => {
+export const toNativeCounterparty = (counterparty: Counterparty): NativeCounterparty => {
   switch (counterparty.kind) {
-    case "user":
-      return { userCounterparty: counterparty };
-    case "merchant":
-      return { merchantCounterparty: counterparty };
-    case "service":
-      return { serviceCounterparty: counterparty };
+    case 'user': {
+      return { userCounterparty: counterparty }
+    }
+    case 'merchant': {
+      return { merchantCounterparty: counterparty }
+    }
+    case 'service': {
+      return { serviceCounterparty: counterparty }
+    }
   }
-};
+}
 
 export const toNativeTradeAssetQuoteRequest = (
-  tradeAssetQuoteRequest: TradeAssetQuoteRequest
-): _TradeAssetQuoteRequest => {
+  tradeAssetQuoteRequest: TradeAssetQuoteRequest,
+): NativeTradeAssetQuoteRequest => {
   switch (tradeAssetQuoteRequest.assetKind) {
-    case "fiat":
-      return { fiatAssetQuoteRequest: tradeAssetQuoteRequest };
-    case "stock":
-    case "crypto":
-      return { marketAssetQuoteRequest: tradeAssetQuoteRequest };
-    case "transport":
-      return { transportAssetQuoteRequest: tradeAssetQuoteRequest };
-    case "other":
-      return { otherAssetQuoteRequest: tradeAssetQuoteRequest };
-    case "nothing":
-      return { nothingAssetQuoteRequest: tradeAssetQuoteRequest };
+    case 'fiat': {
+      return { fiatAssetQuoteRequest: tradeAssetQuoteRequest }
+    }
+    case 'stock': {
+      return { stockAssetQuoteRequest: tradeAssetQuoteRequest }
+    }
+    case 'crypto': {
+      return { cryptoAssetQuoteRequest: tradeAssetQuoteRequest }
+    }
+    case 'transport': {
+      return { transportAssetQuoteRequest: tradeAssetQuoteRequest }
+    }
+    case 'event': {
+      return { eventAssetQuoteRequest: tradeAssetQuoteRequest }
+    }
+    case 'other': {
+      return { otherAssetQuoteRequest: tradeAssetQuoteRequest }
+    }
+    case 'nothing': {
+      return { nothingAssetQuoteRequest: tradeAssetQuoteRequest }
+    }
   }
-};
+}
 
 export const toNativeCounterpartyQuoteRequest = (
-  counterpartyQuoteRequest: CounterpartyQuoteRequest
-): _CounterpartyQuoteRequest => {
+  counterpartyQuoteRequest: CounterpartyQuoteRequest,
+): NativeCounterpartyQuoteRequest => {
   switch (counterpartyQuoteRequest.kind) {
-    case "user":
-      return { userCounterpartyQuoteRequest: counterpartyQuoteRequest };
-    case "merchant":
-      return { merchantCounterpartyQuoteRequest: counterpartyQuoteRequest };
-    case "service":
-      return { serviceCounterpartyQuoteRequest: counterpartyQuoteRequest };
+    case 'user': {
+      return { userCounterpartyQuoteRequest: counterpartyQuoteRequest }
+    }
+    case 'merchant': {
+      return { merchantCounterpartyQuoteRequest: counterpartyQuoteRequest }
+    }
+    case 'service': {
+      return { serviceCounterpartyQuoteRequest: counterpartyQuoteRequest }
+    }
   }
-};
+}
 
 // TO composite types
 
 export const toNativeTradeQuote = (
-  tradeQuote: TradeQuote<TradeQuoteAssetKind, TradeQuoteAssetKind>
-): _TradeQuote => ({
+  tradeQuote: TradeQuote<TradeQuoteAssetKind, TradeQuoteAssetKind>,
+): NativeTradeQuote => ({
   ...tradeQuote,
   gained: toNativeTradeAsset(tradeQuote.gained),
   lost: toNativeTradeAsset(tradeQuote.lost),
   counterparty: toNativeCounterparty(tradeQuote.counterparty),
-});
+})
 
 export const toNativeTradeQuoteRequest = (
-  tradeQuoteRequest: TradeQuotesRequest<
-    TradeQuoteAssetKind,
-    TradeQuoteAssetKind
-  >
-): _TradeQuotesRequest => ({
-  ...tradeQuoteRequest,
+  tradeQuoteRequest: TradeQuotesRequest<TradeQuoteAssetKind, TradeQuoteAssetKind>,
+): NativeTradeQuotesRequest => ({
+  linkedAccountIDs: tradeQuoteRequest.linkedAccountIDs,
   gained: toNativeTradeAssetQuoteRequest(tradeQuoteRequest.gained),
   lost: toNativeTradeAssetQuoteRequest(tradeQuoteRequest.lost),
   counterparty:
     tradeQuoteRequest.counterparty === undefined
       ? undefined
       : toNativeCounterpartyQuoteRequest(tradeQuoteRequest.counterparty),
-});
+})
 
-export const toNativeTradeRef = (tradeRef: TradeRef): _TradeRef => ({
+export const toNativeTradeRef = (tradeRef: TradeRef): NativeTradeRef => ({
   gained: toNativeTradeAssetRef(tradeRef.gained),
   lost: toNativeTradeAssetRef(tradeRef.lost),
-});
+})
 
 // FROM discriminated unions
 
-export const fromNativeTradeAsset = (
-  nativeTradeAsset: _TradeAsset
-): TradeAsset => {
-  const {
-    fiatAsset,
-    marketTradeAsset,
-    transportAsset,
-    otherAsset,
-    nothingAsset,
-  } = nativeTradeAsset;
-
-  if (fiatAsset !== undefined) {
+export const fromNativeTradeAsset = (nativeTradeAsset: NativeTradeAsset): TradeAsset => {
+  if (nativeTradeAsset.fiatAsset !== undefined) {
+    return {
+      ...nativeTradeAsset.fiatAsset,
+      assetKind: 'fiat',
+    }
+  } else if (nativeTradeAsset.cryptoAsset !== undefined) {
     return {
-      ...fiatAsset,
-      assetKind: "fiat",
-    };
-  } else if (marketTradeAsset !== undefined) {
+      ...nativeTradeAsset.cryptoAsset,
+      assetKind: 'crypto',
+    }
+  } else if (nativeTradeAsset.stockAsset !== undefined) {
     return {
-      ...marketTradeAsset,
-      assetKind: marketTradeAsset.assetKind,
-    };
-  } else if (transportAsset !== undefined) {
+      ...nativeTradeAsset.stockAsset,
+      assetKind: 'stock',
+    }
+  } else if (nativeTradeAsset.transportAsset !== undefined) {
     return {
-      ...transportAsset,
-      assetKind: "transport",
-    };
-  } else if (otherAsset !== undefined) {
-    return { assetKind: "other" };
-  } else if (nothingAsset !== undefined) {
-    return { assetKind: "nothing" };
-  } else {
-    throw new Error("Internal Candle Error: corrupted trade asset.");
+      ...nativeTradeAsset.transportAsset,
+      assetKind: 'transport',
+    }
+  } else if (nativeTradeAsset.eventAsset !== undefined) {
+    return {
+      ...nativeTradeAsset.eventAsset,
+      assetKind: 'event',
+    }
+  } else if (nativeTradeAsset.otherAsset !== undefined) {
+    return { assetKind: 'other' }
+  } else if (nativeTradeAsset.nothingAsset !== undefined) {
+    return { assetKind: 'nothing' }
   }
-};
-
-export const fromNativeCounterparty = (
-  nativeCounterparty: _Counterparty
-): Counterparty => {
-  const { merchantCounterparty, userCounterparty, serviceCounterparty } =
-    nativeCounterparty;
+  throw new Error('Internal Candle Error: corrupted trade asset.')
+}
 
-  if (merchantCounterparty !== undefined) {
+export const fromNativeCounterparty = (nativeCounterparty: NativeCounterparty): Counterparty => {
+  if (nativeCounterparty.merchantCounterparty !== undefined) {
     return {
-      ...merchantCounterparty,
-      kind: "merchant",
-    };
-  } else if (userCounterparty !== undefined) {
+      ...nativeCounterparty.merchantCounterparty,
+      kind: 'merchant',
+    }
+  } else if (nativeCounterparty.userCounterparty !== undefined) {
     return {
-      ...userCounterparty,
-      kind: "user",
-    };
-  } else if (serviceCounterparty !== undefined) {
+      ...nativeCounterparty.userCounterparty,
+      kind: 'user',
+    }
+  } else if (nativeCounterparty.serviceCounterparty !== undefined) {
     return {
-      ...serviceCounterparty,
-      kind: "service",
-    };
-  } else {
-    throw new Error("Internal Candle Error: corrupted counterparty.");
+      ...nativeCounterparty.serviceCounterparty,
+      kind: 'service',
+    }
   }
-};
-
-export const fromNativeAssetAccount = (
-  nativeAssetAccount: _AssetAccount
-): AssetAccount => {
-  const { fiatAccount, marketAccount, transportAccount } = nativeAssetAccount;
+  throw new Error('Internal Candle Error: corrupted counterparty.')
+}
 
-  if (fiatAccount !== undefined) {
+export const fromNativeAssetAccount = (nativeAssetAccount: NativeAssetAccount): AssetAccount => {
+  if (nativeAssetAccount.fiatAccount !== undefined) {
     return {
-      ...fiatAccount,
-      assetKind: "fiat",
-    };
-  } else if (marketAccount !== undefined) {
+      ...nativeAssetAccount.fiatAccount,
+      assetKind: 'fiat',
+    }
+  } else if (nativeAssetAccount.cryptoAccount !== undefined) {
     return {
-      ...marketAccount,
-      assetKind: marketAccount.assetKind,
-    };
-  } else if (transportAccount !== undefined) {
+      ...nativeAssetAccount.cryptoAccount,
+      assetKind: 'crypto',
+    }
+  } else if (nativeAssetAccount.stockAccount !== undefined) {
     return {
-      ...transportAccount,
-      assetKind: "transport",
-    };
-  } else {
-    throw new Error("Internal Candle Error: corrupted asset account.");
+      ...nativeAssetAccount.stockAccount,
+      assetKind: 'stock',
+    }
+  } else if (nativeAssetAccount.transportAccount !== undefined) {
+    return {
+      ...nativeAssetAccount.transportAccount,
+      assetKind: 'transport',
+    }
   }
-};
+  throw new Error('Internal Candle Error: corrupted asset account.')
+}
 
 export const fromNativeLinkedAccountDetails = (
-  nativeLinkedAccountDetails: _LinkedAccountDetails
+  nativeLinkedAccountDetails: NativeLinkedAccountDetails,
 ): LinkedAccountDetails => {
-  const {
-    activeLinkedAccountDetails,
-    inactiveLinkedAccountDetails,
-    unavailableLinkedAccountDetails,
-  } = nativeLinkedAccountDetails;
-
-  if (activeLinkedAccountDetails !== undefined) {
+  if (nativeLinkedAccountDetails.activeLinkedAccountDetails !== undefined) {
     return {
-      ...activeLinkedAccountDetails,
-      state: "active",
-    };
-  } else if (inactiveLinkedAccountDetails !== undefined) {
+      ...nativeLinkedAccountDetails.activeLinkedAccountDetails,
+      state: 'active',
+    }
+  } else if (nativeLinkedAccountDetails.inactiveLinkedAccountDetails !== undefined) {
     return {
-      ...inactiveLinkedAccountDetails,
-      state: "inactive",
-    };
-  } else if (unavailableLinkedAccountDetails !== undefined) {
+      ...nativeLinkedAccountDetails.inactiveLinkedAccountDetails,
+      state: 'inactive',
+    }
+  } else if (nativeLinkedAccountDetails.unavailableLinkedAccountDetails !== undefined) {
     return {
-      ...unavailableLinkedAccountDetails,
-      state: "unavailable",
-    };
-  } else {
-    throw new Error("Internal Candle Error: corrupted linked account details");
+      ...nativeLinkedAccountDetails.unavailableLinkedAccountDetails,
+      state: 'unavailable',
+    }
   }
-};
+  throw new Error('Internal Candle Error: corrupted linked account details')
+}
 
 // FROM composite types
 
 export const fromNativeLinkedAccount = (
-  nativeLinkedAccount: _LinkedAccount
+  nativeLinkedAccount: NativeLinkedAccount,
 ): LinkedAccount => ({
   ...nativeLinkedAccount,
   details: fromNativeLinkedAccountDetails(nativeLinkedAccount.details),
-});
+})
 
 export const fromNativeTrade = (
-  nativeTrade: _Trade
+  nativeTrade: NativeTrade,
 ): Trade<TradeAssetKind, TradeAssetKind> => ({
   ...nativeTrade,
   counterparty: fromNativeCounterparty(nativeTrade.counterparty),
   lost: fromNativeTradeAsset(nativeTrade.lost),
   gained: fromNativeTradeAsset(nativeTrade.gained),
-});
+})
 
 export const fromNativeTradeAndQuote =
-  <
-    GainedAssetKind extends TradeQuoteAssetKind,
-    LostAssetKind extends TradeQuoteAssetKind
-  >(
-    tradeQuote: TradeQuote<GainedAssetKind, LostAssetKind>
+  <GainedAssetKind extends TradeQuoteAssetKind, LostAssetKind extends TradeQuoteAssetKind>(
+    tradeQuote: TradeQuote<GainedAssetKind, LostAssetKind>,
   ) =>
-  (nativeTrade: _Trade): Trade<GainedAssetKind, LostAssetKind> => ({
+  (nativeTrade: NativeTrade): Trade<GainedAssetKind, LostAssetKind> => ({
     ...nativeTrade,
     counterparty: fromNativeCounterparty(nativeTrade.counterparty),
     gained: assertTradeAsset({
@@ -471,18 +454,13 @@ export const fromNativeTradeAndQuote =
       tradeAsset: fromNativeTradeAsset(nativeTrade.lost),
       expectedAssetKind: tradeQuote.lost.assetKind,
     }),
-  });
+  })
 
 export const fromNativeTradeQuoteAndRequest =
-  <
-    GainedAssetKind extends TradeQuoteAssetKind,
-    LostAssetKind extends TradeQuoteAssetKind
-  >(
-    tradeQuoteRequest: TradeQuotesRequest<GainedAssetKind, LostAssetKind>
+  <GainedAssetKind extends TradeQuoteAssetKind, LostAssetKind extends TradeQuoteAssetKind>(
+    tradeQuoteRequest: TradeQuotesRequest<GainedAssetKind, LostAssetKind>,
   ) =>
-  (
-    nativeTradeQuote: _TradeQuote
-  ): TradeQuote<GainedAssetKind, LostAssetKind> => ({
+  (nativeTradeQuote: NativeTradeQuote): TradeQuote<GainedAssetKind, LostAssetKind> => ({
     ...nativeTradeQuote,
     gained: assertTradeAsset({
       tradeAsset: fromNativeTradeAsset(nativeTradeQuote.gained),
@@ -493,23 +471,20 @@ export const fromNativeTradeQuoteAndRequest =
       expectedAssetKind: tradeQuoteRequest.lost.assetKind,
     }),
     counterparty: fromNativeCounterparty(nativeTradeQuote.counterparty),
-  });
+  })
 
 // Generics assertions
 
-export const assertTradeAsset = <
-  ExpectedAssetKind extends TradeQuoteAssetKind
->(input: {
-  tradeAsset: TradeAsset;
-  expectedAssetKind: ExpectedAssetKind;
+export const assertTradeAsset = <ExpectedAssetKind extends TradeQuoteAssetKind>(input: {
+  tradeAsset: TradeAsset
+  expectedAssetKind: ExpectedAssetKind
 }): TradeAsset & {
-  assetKind: ExpectedAssetKind;
+  assetKind: ExpectedAssetKind
 } => {
+  // FIXME: This cast is due to a TypeScript generics limitation and should be cleaned up when possible.
   if (input.tradeAsset.assetKind !== input.expectedAssetKind) {
-    throw new Error("Internal Candle Error: unexpected trade asset kind.");
+    throw new Error('Internal Candle Error: unexpected trade asset kind.')
   }
-  // NOTE: This cast is due to a TypeScript generics limitation and should be cleaned up when possible
-  return input.tradeAsset as TradeAsset & {
-    assetKind: ExpectedAssetKind;
-  };
-};
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return input.tradeAsset as TradeAsset & { assetKind: ExpectedAssetKind }
+}