1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-05 15:35:46 +01:00
metamask-extension/ui/pages/first-time-flow/seed-phrase/confirm-seed-phrase/confirm-seed-phrase.component.js
Erik Marks a8c1756816
Remove 3box feature and delete ThreeBoxController (#14571)
* Remove 3box feature and delete ThreeBoxController

Lint locale messages

lavamoat policy updates

* Restore 3Box user trait with value `false`

The 3Box user trait has been restored and hard-coded as `false`. This
ensures that users don't get stuck in our metrics as having this trait.

A deprecation comment has been left in various places for this trait.

* Remove unused state

* Remove additional 3box-related things

* Run `yarn-deduplicate`

* Restore migration that was lost while rebasing

* Remove obsolete override

* Remove additional unused resolutions/dependencies

* Update LavaMoat policies

* Remove obsolete security advisory ignore entries

* Remove 3Box fixture builder method

* Update unit tests

Co-authored-by: Mark Stacey <markjstacey@gmail.com>
2022-10-31 13:50:50 -02:30

292 lines
7.8 KiB
JavaScript

import React, { PureComponent } from 'react';
import PropTypes from 'prop-types';
import classnames from 'classnames';
import Button from '../../../../components/ui/button';
import {
INITIALIZE_END_OF_FLOW_ROUTE,
INITIALIZE_SEED_PHRASE_ROUTE,
} from '../../../../helpers/constants/routes';
import {
EVENT,
EVENT_NAMES,
} from '../../../../../shared/constants/metametrics';
import { exportAsFile } from '../../../../helpers/utils/export-utils';
import DraggableSeed from './draggable-seed.component';
const EMPTY_SEEDS = Array(12).fill(null);
export default class ConfirmSeedPhrase extends PureComponent {
static contextTypes = {
trackEvent: PropTypes.func,
t: PropTypes.func,
};
static defaultProps = {
seedPhrase: '',
};
static propTypes = {
history: PropTypes.object,
seedPhrase: PropTypes.string,
setSeedPhraseBackedUp: PropTypes.func,
};
state = {
selectedSeedIndices: [],
sortedSeedWords: [],
pendingSeedIndices: [],
draggingSeedIndex: -1,
hoveringIndex: -1,
};
componentDidMount() {
const { seedPhrase = '' } = this.props;
const sortedSeedWords = (seedPhrase.split(' ') || []).sort();
this.setState({ sortedSeedWords });
}
setDraggingSeedIndex = (draggingSeedIndex) =>
this.setState({ draggingSeedIndex });
setHoveringIndex = (hoveringIndex) => this.setState({ hoveringIndex });
onDrop = (targetIndex) => {
const { selectedSeedIndices, draggingSeedIndex } = this.state;
const indices = insert(
selectedSeedIndices,
draggingSeedIndex,
targetIndex,
true,
);
this.setState({
selectedSeedIndices: indices,
pendingSeedIndices: indices,
draggingSeedIndex: -1,
hoveringIndex: -1,
});
};
handleExport = () => {
exportAsFile('', this.props.seedPhrase, 'text/plain');
};
handleSubmit = async () => {
const { history, setSeedPhraseBackedUp } = this.props;
if (!this.isValid()) {
return;
}
try {
setSeedPhraseBackedUp(true).then(async () => {
this.context.trackEvent({
category: EVENT.CATEGORIES.ONBOARDING,
event: EVENT_NAMES.WALLET_CREATED,
properties: {
account_type: EVENT.ACCOUNT_TYPES.DEFAULT,
is_backup_skipped: false,
},
});
history.replace(INITIALIZE_END_OF_FLOW_ROUTE);
});
} catch (error) {
console.error(error.message);
this.context.trackEvent({
category: EVENT.CATEGORIES.ONBOARDING,
event: EVENT_NAMES.WALLET_SETUP_FAILED,
properties: {
account_type: EVENT.ACCOUNT_TYPES.DEFAULT,
is_backup_skipped: false,
reason: 'Seed Phrase Creation Error',
error: error.message,
},
});
}
};
handleSelectSeedWord = (index) => {
this.setState({
selectedSeedIndices: [...this.state.selectedSeedIndices, index],
pendingSeedIndices: [...this.state.pendingSeedIndices, index],
});
};
handleDeselectSeedWord = (index) => {
this.setState({
selectedSeedIndices: this.state.selectedSeedIndices.filter(
(i) => index !== i,
),
pendingSeedIndices: this.state.pendingSeedIndices.filter(
(i) => index !== i,
),
});
};
isValid() {
const { seedPhrase } = this.props;
const { selectedSeedIndices, sortedSeedWords } = this.state;
const selectedSeedWords = selectedSeedIndices.map(
(i) => sortedSeedWords[i],
);
return seedPhrase === selectedSeedWords.join(' ');
}
render() {
const { t } = this.context;
const { history } = this.props;
const { selectedSeedIndices, sortedSeedWords, draggingSeedIndex } =
this.state;
return (
<div className="confirm-seed-phrase" data-testid="confirm-seed-phrase">
<div className="confirm-seed-phrase__back-button">
<a
onClick={(e) => {
e.preventDefault();
history.push(INITIALIZE_SEED_PHRASE_ROUTE);
}}
href="#"
>
{`< ${t('back')}`}
</a>
</div>
<div className="first-time-flow__header">
{t('confirmSecretBackupPhrase')}
</div>
<div className="first-time-flow__text-block">
{t('selectEachPhrase')}
</div>
<div
className={classnames('confirm-seed-phrase__selected-seed-words', {
'confirm-seed-phrase__selected-seed-words--dragging':
draggingSeedIndex > -1,
})}
>
{this.renderPendingSeeds()}
{this.renderSelectedSeeds()}
</div>
<div
className="confirm-seed-phrase__sorted-seed-words"
data-testid="seed-phrase-sorted"
>
{sortedSeedWords.map((word, index) => {
const isSelected = selectedSeedIndices.includes(index);
return (
<DraggableSeed
key={index}
seedIndex={index}
index={index}
setHoveringIndex={this.setHoveringIndex}
onDrop={this.onDrop}
className="confirm-seed-phrase__seed-word--sorted"
selected={isSelected}
onClick={() => {
if (isSelected) {
this.handleDeselectSeedWord(index);
} else {
this.handleSelectSeedWord(index);
}
}}
word={word}
/>
);
})}
</div>
<Button
type="primary"
className="first-time-flow__button"
onClick={this.handleSubmit}
disabled={!this.isValid()}
>
{t('confirm')}
</Button>
</div>
);
}
renderSelectedSeeds() {
const { sortedSeedWords, selectedSeedIndices, draggingSeedIndex } =
this.state;
return EMPTY_SEEDS.map((_, index) => {
const seedIndex = selectedSeedIndices[index];
const word = sortedSeedWords[seedIndex];
return (
<DraggableSeed
key={`selected-${seedIndex}-${index}`}
className="confirm-seed-phrase__selected-seed-words__selected-seed"
index={index}
seedIndex={seedIndex}
word={word}
draggingSeedIndex={draggingSeedIndex}
setDraggingSeedIndex={this.setDraggingSeedIndex}
setHoveringIndex={this.setHoveringIndex}
onDrop={this.onDrop}
draggable
/>
);
});
}
renderPendingSeeds() {
const {
pendingSeedIndices,
sortedSeedWords,
draggingSeedIndex,
hoveringIndex,
} = this.state;
const indices = insert(
pendingSeedIndices,
draggingSeedIndex,
hoveringIndex,
);
return EMPTY_SEEDS.map((_, index) => {
const seedIndex = indices[index];
const word = sortedSeedWords[seedIndex];
return (
<DraggableSeed
key={`pending-${seedIndex}-${index}`}
index={index}
className={classnames(
'confirm-seed-phrase__selected-seed-words__pending-seed',
{
'confirm-seed-phrase__seed-word--hidden':
draggingSeedIndex === seedIndex && index !== hoveringIndex,
},
)}
seedIndex={seedIndex}
word={word}
draggingSeedIndex={draggingSeedIndex}
setDraggingSeedIndex={this.setDraggingSeedIndex}
setHoveringIndex={this.setHoveringIndex}
onDrop={this.onDrop}
droppable={Boolean(word)}
/>
);
});
}
}
function insert(list, value, target, removeOld) {
let nextList = [...list];
if (typeof list[target] === 'number') {
nextList = [...list.slice(0, target), value, ...list.slice(target)];
}
if (removeOld) {
nextList = nextList.filter((seed, i) => {
return seed !== value || i === target;
});
}
return nextList;
}