1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-23 01:39:44 +01:00
metamask-extension/ui/store/institutional/institution-background.ts
Albert Olivé 057188d155
[MMI] Add code fences in signature-request (#18770)
* Started adding code fences in signature-request

* Finished code fencing

* Improving code

* Fixed storybook and code fences bundle

* Added missing dependency

* Fixed yarn.lock

* Fixing policies

* Updated package.json

* updating lavamoat

* lavamoat fix

* adds missing package

* runs yarn dedupe

* updates method name

* run lavamoat:auto again

* Added more code fences

* updates snapshot

* snapshot updates

* updates mmi packages to lighter versions

* updates mmi packages

* runs lavamoat auto

* updates yarn lock and runs lavamoat auto

* updates yarn lock

* updates targets file

* Removed console log and added tests

---------

Co-authored-by: António Regadas <apregadas@gmail.com>
Co-authored-by: Brad Decker <bhdecker84@gmail.com>
Co-authored-by: Antonio Regadas <antonio.regadas@consensys.net>
2023-05-24 13:41:21 +02:00

232 lines
6.7 KiB
TypeScript

import log from 'loglevel';
import { ThunkAction } from 'redux-thunk';
import { AnyAction } from 'redux';
import {
forceUpdateMetamaskState,
displayWarning,
hideLoadingIndication,
showLoadingIndication,
} from '../actions';
import {
callBackgroundMethod,
submitRequestToBackground,
} from '../action-queue';
import { MetaMaskReduxState } from '../store';
import { isErrorWithMessage } from '../../../shared/modules/error';
export function showInteractiveReplacementTokenBanner({
url,
oldRefreshToken,
}: {
url: string;
oldRefreshToken: string;
}): ThunkAction<void, MetaMaskReduxState, unknown, AnyAction> {
return async (dispatch) => {
try {
await submitRequestToBackground('showInteractiveReplacementTokenBanner', [
url,
oldRefreshToken,
]);
} catch (err: any) {
if (err) {
dispatch(displayWarning(err.message));
throw new Error(err.message);
}
}
};
}
export function setTypedMessageInProgress(msgId: string) {
return async (dispatch: any) => {
dispatch(showLoadingIndication());
try {
await submitRequestToBackground('setTypedMessageInProgress', [msgId]);
} catch (error: any) {
log.error(error);
dispatch(displayWarning(error.message));
} finally {
await forceUpdateMetamaskState(dispatch);
dispatch(hideLoadingIndication());
}
};
}
/**
* A factory that contains all MMI actions ready to use
* Example usage:
* const mmiActions = mmiActionsFactory();
* mmiActions.connectCustodyAddresses(...)
*/
export function mmiActionsFactory() {
function createAsyncAction(
name: string,
params: any,
useForceUpdateMetamaskState?: any,
loadingText?: string,
): ThunkAction<void, MetaMaskReduxState, unknown, AnyAction> {
log.debug(`background.${name}`);
return async (dispatch: any) => {
if (loadingText) {
dispatch(showLoadingIndication(loadingText));
}
let result;
try {
result = await submitRequestToBackground(name, [...params]);
} catch (error) {
dispatch(displayWarning(error));
if (isErrorWithMessage(error)) {
throw new Error(error.message);
} else {
throw error;
}
}
if (loadingText) {
dispatch(hideLoadingIndication());
}
if (useForceUpdateMetamaskState) {
await forceUpdateMetamaskState(dispatch);
}
return result;
};
}
function createAction(name: string, payload: any) {
return () => {
callBackgroundMethod(name, [payload], (err) => {
if (isErrorWithMessage(err)) {
throw new Error(err.message);
}
});
};
}
return {
connectCustodyAddresses: (
custodianType: string,
custodianName: string,
newAccounts: string[],
) =>
createAsyncAction(
'connectCustodyAddresses',
[custodianType, custodianName, newAccounts],
forceUpdateMetamaskState,
'Looking for your custodian account...',
),
getCustodianAccounts: (
token: string,
apiUrl: string,
custody: string,
getNonImportedAccounts: boolean,
) =>
createAsyncAction(
'getCustodianAccounts',
[token, apiUrl, custody, getNonImportedAccounts],
forceUpdateMetamaskState,
'Getting custodian accounts...',
),
getCustodianAccountsByAddress: (
jwt: string,
apiUrl: string,
address: string,
custody: string,
) =>
createAsyncAction(
'getCustodianAccountsByAddress',
[jwt, apiUrl, address, custody],
forceUpdateMetamaskState,
'Getting custodian accounts...',
),
getCustodianTransactionDeepLink: (address: string, txId: string) =>
createAsyncAction(
'getCustodianTransactionDeepLink',
[address, txId],
forceUpdateMetamaskState,
),
getCustodianConfirmDeepLink: (txId: string) =>
createAsyncAction(
'getCustodianConfirmDeepLink',
[txId],
forceUpdateMetamaskState,
),
getCustodianSignMessageDeepLink: (from: string, custodyTxId: string) =>
createAsyncAction(
'getCustodianSignMessageDeepLink',
[from, custodyTxId],
forceUpdateMetamaskState,
),
getCustodianToken: (custody: string) =>
createAsyncAction(
'getCustodianToken',
[custody],
forceUpdateMetamaskState,
),
getCustodianJWTList: (custody: string) =>
createAsyncAction(
'getCustodianJWTList',
[custody],
forceUpdateMetamaskState,
),
setWaitForConfirmDeepLinkDialog: (waitForConfirmDeepLinkDialog: boolean) =>
createAction(
'setWaitForConfirmDeepLinkDialog',
waitForConfirmDeepLinkDialog,
),
setComplianceAuthData: (clientId: string, projectId: string) =>
createAsyncAction('setComplianceAuthData', [{ clientId, projectId }]),
deleteComplianceAuthData: () =>
createAsyncAction('deleteComplianceAuthData', []),
generateComplianceReport: (address: string) =>
createAction('generateComplianceReport', address),
getComplianceHistoricalReportsByAddress: (
address: string,
projectId: string,
) =>
createAsyncAction('getComplianceHistoricalReportsByAddress', [
address,
projectId,
]),
syncReportsInProgress: (address: string, historicalReports: []) =>
createAction('syncReportsInProgress', { address, historicalReports }),
removeConnectInstitutionalFeature: (origin: string, projectId: string) =>
createAction('removeConnectInstitutionalFeature', { origin, projectId }),
removeAddTokenConnectRequest: (
origin: string,
apiUrl: string,
token: string,
) =>
createAction('removeAddTokenConnectRequest', { origin, apiUrl, token }),
setCustodianConnectRequest: (
token: string,
apiUrl: string,
custodianType: string,
custodianName: string,
) =>
createAsyncAction('setCustodianConnectRequest', [
{ token, apiUrl, custodianType, custodianName },
]),
getCustodianConnectRequest: () =>
createAsyncAction('getCustodianConnectRequest', []),
getMmiConfiguration: () => createAsyncAction('getMmiConfiguration', []),
getAllCustodianAccountsWithToken: (custodyType: string, token: string) =>
createAsyncAction('getAllCustodianAccountsWithToken', [
custodyType,
token,
]),
setCustodianNewRefreshToken: (
address: string,
oldAuthDetails: string,
oldApiUrl: string,
newAuthDetails: string,
newApiUrl: string,
) =>
createAsyncAction('setCustodianNewRefreshToken', [
address,
oldAuthDetails,
oldApiUrl,
newAuthDetails,
newApiUrl,
]),
};
}