1  import {last} from '../utils/utils';
  2  
  3  export function getCredentials(state) {
  4    return state.credentials;
  5  }
  6  
  7  export function getAuthenticationError(state) {
  8    return state.credentials.error;
  9  }
 10  
 11  export function getTheme(state) {
 12    return state.theme;
 13  }
 14  
 15  export function getAccounts(state) {
 16    return state.entities.accounts;
 17  }
 18  
 19  export function getAccount(state, address) {
 20    return state.entities.accounts.find((account) => account.address === address);
 21  }
 22  
 23  export function getTransactions(state) {
 24    return state.entities.transactions;
 25  }
 26  
 27  export function getTransaction(state, hash) {
 28    return state.entities.transactions.find((transaction) => transaction.hash === hash);
 29  }
 30  
 31  export function getTransactionsByAccount(state, address) {
 32    return state.entities.transactions.filter((transaction) => transaction.from === address);
 33  }
 34  
 35  export function getTransactionsByBlock(state, blockNumber) {
 36    return state.entities.transactions.filter((transaction) => transaction.hasOwnProperty('blockNumber') && transaction.blockNumber.toString() === blockNumber);
 37  }
 38  
 39  export function getBlocks(state) {
 40    return state.entities.blocks;
 41  }
 42  
 43  export function getLastBlock(state) {
 44    return state.entities.blocks[0];
 45  }
 46  
 47  export function getBlock(state, number) {
 48    return state.entities.blocks.find((block) => block.number.toString() === number);
 49  }
 50  
 51  export function getProcesses(state) {
 52    return state.entities.processes;
 53  }
 54  
 55  export function getServices(state) {
 56    return state.entities.services;
 57  }
 58  
 59  export function getProcessLogs(state) {
 60    return state.entities.processLogs;
 61  }
 62  
 63  export function getCommandSuggestions(state) {
 64    return state.entities.commandSuggestions;
 65  }
 66  
 67  export function getContractLogsByContract(state, contractName) {
 68    return state.entities.contractLogs.filter((contractLog => contractLog.name === contractName));
 69  }
 70  
 71  export function getContractEventsByContract(state, contractName) {
 72    return state.entities.contractEvents.filter((contractEvent => contractEvent.name === contractName));
 73  }
 74  
 75  export function getContracts(state) {
 76    return state.entities.contracts.filter(contract => !contract.isFiddle);
 77  }
 78  
 79  export function getFiddleContracts(state) {
 80    return state.entities.contracts.filter(contract => contract.isFiddle);
 81  }
 82  
 83  export function getContract(state, contractName) {
 84    return state.entities.contracts.find((contract => contract.className === contractName));
 85  }
 86  
 87  export function getContractsByPath(state, path) {
 88    return state.entities.contracts.filter((contract => contract.path === path));
 89  }
 90  
 91  export function getContractProfile(state, contractName) {
 92    return state.entities.contractProfiles.find((contractProfile => contractProfile.name === contractName));
 93  }
 94  
 95  export function getContractFunctions(state, contractName) {
 96    return state.entities.contractFunctions.filter((contractFunction => contractFunction.contractName === contractName));
 97  }
 98  
 99  export function getContractDeploys(state, contractName) {
100    return state.entities.contractDeploys.filter((contractDeploy => contractDeploy.contractName === contractName));
101  }
102  
103  export function getContractCompile(state, file) {
104    let contractCompile = state.entities.contractCompiles.reverse().find((contractCompile => contractCompile.name === file.name));
105    if (!contractCompile) return;
106    if (contractCompile.errors) {
107      contractCompile.warnings = contractCompile.errors.filter((error) => error.severity === 'warning');
108      contractCompile.errors = contractCompile.errors.filter((error) => error.severity === 'error');
109    }
110  
111    return contractCompile;
112  }
113  
114  export function getVersions(state) {
115    return state.entities.versions;
116  }
117  
118  export function getOracleGasStats(state) {
119    if (!state.entities.gasOracleStats.length) {
120      return {};
121    }
122    return state.entities.gasOracleStats[0];
123  }
124  
125  export function isWeb3Enabled(state) {
126    return Boolean(state.entities.versions.find((version) => version.name === 'web3'));
127  }
128  
129  export function isOldWeb3(state) {
130    const web3 = state.entities.versions.find((version) => version.name === 'web3');
131    return web3 && parseInt(web3[0], 10) === 0;
132  }
133  
134  export function getMessageChannels(state) {
135    return state.entities.messageChannels;
136  }
137  
138  export function getMessages(state) {
139    const messages = {};
140    state.entities.messages.forEach(message => {
141      if (!messages[message.channel]) {
142        messages[message.channel] = [];
143      }
144      messages[message.channel].push(message);
145    });
146    return messages;
147  }
148  
149  export function getFiddleDeploy(state) {
150    return {
151      data: last(state.entities.fiddleDeploys),
152      error: state.errorEntities.fiddleDeploys
153    };
154  }
155  
156  export function getEnsRecords(state) {
157    return state.entities.ensRecords;
158  }
159  
160  export function getEnsErrors(state) {
161    return state.errorEntities.ensRecords;
162  }
163  
164  export function isEnsEnabled(state) {
165    return Boolean(state.entities.plugins.find((plugin) => plugin.name === 'ens'));
166  }
167  
168  export function getFiles(state) {
169    return state.entities.files;
170  }
171  
172  export function getCurrentFile(state) {
173    return state.editorTabs.find(file => file.active) || {};
174  }
175  
176  export function getBaseEther(state) {
177    return state.baseEther;
178  }
179  
180  export function searchResult(state) {
181    return state.searchResult;
182  }
183  
184  export function getMessageSignaturePendingState(state) {
185    return state.messageSignature.pending;
186  }
187  
188  export function getMessageSignaturePayload(state) {
189    return state.messageSignature.payload ? JSON.stringify(state.messageSignature.payload, null, 2): null;
190  }
191  
192  export function getMessageSignatureError(state) {
193    return state.messageSignature.error;
194  }
195  
196  export function getVerificationPendingState(state) {
197    return state.messageVerification.pending;
198  }
199  
200  export function getVerifiedAddressPayload(state) {
201    return state.messageVerification.payload ? state.messageVerification.payload.verifiedAddress : null;
202  }
203  
204  export function getVerificationError(state) {
205    return state.messageVerification.error;
206  }
207  
208  export function getBreakpointsByFilename(state, filename) {
209    return state.breakpoints[filename] || [];
210  }
211  
212  export function getDeploymentPipeline(state) {
213    return state.deploymentPipeline;
214  }
215  
216  export function getWeb3(state) {
217    return state.web3.instance;
218  }
219  
220  export function getWeb3GasEstimates(state) {
221    return state.web3.gasEstimates;
222  }
223  
224  export function getWeb3Deployments(state) {
225    return state.web3.deployments;
226  }
227  
228  export function debuggerInfo(state) {
229    return state.debuggerInfo;
230  }
231  
232  export function getDebuggerLine(state) {
233    if (!state.debuggerInfo.sources) return 10;
234    return state.debuggerInfo.sources.lineColumnPos[0].start.line + 1;
235  }
236  
237  export function getEditorTabs(state) {
238    return state.editorTabs
239  }