packages/wallet/store/slices/exchangeRate.ts

   1 import { createSlice } from '@reduxjs/toolkit';
   2
   3 import type { ModelState } from '@proton/account';
   4 import { getInitialModelState } from '@proton/account';
   5 import type { WasmApiExchangeRate, WasmFiatCurrencySymbol } from '@proton/andromeda';
   6 import { createAsyncModelThunk, handleAsyncModel } from '@proton/redux-utilities';
   7 import { SECOND } from '@proton/shared/lib/constants';
   8 import { type SimpleMap } from '@proton/shared/lib/interfaces';
   9
  10 import type { WalletThunkArguments } from '../thunk';
  11
  12 const name = 'exchange_rate' as const;
  13
  14 type WasmApiExchangeRateByFiat = SimpleMap<WasmApiExchangeRate>;
  15
  16 export interface ExchangeRateState {
  17     [name]: ModelState<WasmApiExchangeRateByFiat>;
  18 }
  19
  20 type SliceState = ExchangeRateState[typeof name];
  21 type Model = NonNullable<SliceState['value']>;
  22
  23 export const selectExchangeRate = (state: ExchangeRateState) => {
  24     return state[name];
  25 };
  26
  27 const SEPARATOR = '-';
  28
  29 export const serialiseKey = (fiat: WasmFiatCurrencySymbol, timestamp?: number) => {
  30     return timestamp ? `${fiat}${SEPARATOR}${Number(timestamp)}` : fiat;
  31 };
  32 export const parseKey = (key: string) => {
  33     const [fiat, timestamp] = key.split(SEPARATOR) as [WasmFiatCurrencySymbol, string?];
  34
  35     return {
  36         fiat,
  37         timestamp: timestamp ? Number(timestamp) : undefined,
  38     };
  39 };
  40
  41 export const getKeyAndTs = (fiat: WasmFiatCurrencySymbol, date?: Date) => {
  42     const ts = date?.getTime();
  43     const key = serialiseKey(fiat, ts);
  44
  45     // API expects ts in seconds
  46     const tsInSeconds = ts && Math.floor(ts / SECOND);
  47
  48     return [key, tsInSeconds] as const;
  49 };
  50
  51 const modelThunk = createAsyncModelThunk<
  52     Model,
  53     ExchangeRateState,
  54     WalletThunkArguments,
  55     [WasmFiatCurrencySymbol, Date?]
  56 >(`${name}/fetch`, {
  57     miss: async ({ extraArgument, options, getState }) => {
  58         const stateValue = getState()[name].value;
  59         if (!options?.thunkArg) {
  60             return stateValue ?? {};
  61         }
  62
  63         const fiat = options?.thunkArg?.[0] ?? 'USD';
  64         const date = options?.thunkArg?.[1];
  65
  66         const [key, ts] = getKeyAndTs(fiat, date);
  67
  68         try {
  69             const exchangeRate = await extraArgument.walletApi
  70                 .clients()
  71                 .exchange_rate.getExchangeRate(fiat, ts ? BigInt(ts) : undefined)
  72                 .then((data) => {
  73                     return data.Data;
  74                 });
  75
  76             return {
  77                 ...stateValue,
  78                 [key]: exchangeRate,
  79             };
  80         } catch {
  81             return stateValue ?? {};
  82         }
  83     },
  84     previous: ({ getState, options }) => {
  85         const state = getState()[name];
  86
  87         if (!options?.thunkArg || !state.value) {
  88             return undefined;
  89         }
  90
  91         const [fiat, date] = options?.thunkArg;
  92         const [key] = getKeyAndTs(fiat, date);
  93
  94         if (state.value[key]) {
  95             return state;
  96         }
  97
  98         return undefined;
  99     },
 100 });
 101
 102 const initialState = getInitialModelState<Model>();
 103
 104 const slice = createSlice({
 105     name,
 106     initialState,
 107     reducers: {},
 108     extraReducers: (builder) => {
 109         handleAsyncModel(builder, modelThunk);
 110     },
 111 });
 112
 113 export const exchangeRateReducer = { [name]: slice.reducer };
 114 export const exchangeRateThunk = modelThunk.thunk;