diff --git a/CHANGELOG.md b/CHANGELOG.md index 743ffb254795..f3c2079ff254 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +## [10.20.0] +### Changed +- Deprecate Rinkeby, Ropsten and Kovan test networks and define Goerli as the default network in test mode ([#15989](https://github.com/MetaMask/metamask-extension/pull/15989)) + +### Fixed +- [FLASK] Fix crash when uninstalling snap ([#15799](https://github.com/MetaMask/metamask-extension/pull/15799)) +- [FLASK] Fix crash with certain permissions on the snap settings page ([#15797](https://github.com/MetaMask/metamask-extension/pull/15797)) +- [FLASK] Fix an issue with installing and updating snaps with 0 permissions ([#15796](https://github.com/MetaMask/metamask-extension/pull/15796)) + ## [10.19.0] ### Added - Add ENS wildcard and secure offchain resolution (ENSIP-10 & EIP3668) ([#14675](https://github.com/MetaMask/metamask-extension/pull/14675)) @@ -3189,7 +3198,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Uncategorized - Added the ability to restore accounts from seed words. -[Unreleased]: https://github.com/MetaMask/metamask-extension/compare/v10.19.0...HEAD +[Unreleased]: https://github.com/MetaMask/metamask-extension/compare/v10.20.0...HEAD +[10.20.0]: https://github.com/MetaMask/metamask-extension/compare/v10.19.0...v10.20.0 [10.19.0]: https://github.com/MetaMask/metamask-extension/compare/v10.18.4...v10.19.0 [10.18.4]: https://github.com/MetaMask/metamask-extension/compare/v10.18.3...v10.18.4 [10.18.3]: https://github.com/MetaMask/metamask-extension/compare/v10.18.2...v10.18.3 diff --git a/app/images/aurora.png b/app/images/aurora.png new file mode 100644 index 000000000000..5c59ca5eb91b Binary files /dev/null and b/app/images/aurora.png differ diff --git a/app/images/icons/icon-search-filled.svg b/app/images/icons/icon-search-filled.svg index 88b36fc089da..267caca92714 100644 --- a/app/images/icons/icon-search-filled.svg +++ b/app/images/icons/icon-search-filled.svg @@ -1,3 +1,3 @@ - + diff --git a/app/manifest/v3/_base.json b/app/manifest/v3/_base.json index 59cb72718377..1b9456fd8d93 100644 --- a/app/manifest/v3/_base.json +++ b/app/manifest/v3/_base.json @@ -49,10 +49,9 @@ "description": "__MSG_appDescription__", "host_permissions": [ "http://localhost:8545/", - "https://*.infura.io/", - "https://chainid.network/chains.json", - "https://lattice.gridplus.io/*", - "*://*.eth/" + "file://*/*", + "http://*/*", + "https://*/*" ], "icons": { "16": "images/icon-16.png", diff --git a/app/scripts/controllers/network/createInfuraClient.test.js b/app/scripts/controllers/network/createInfuraClient.test.js index 4e5fb32b6cb8..404489ece544 100644 --- a/app/scripts/controllers/network/createInfuraClient.test.js +++ b/app/scripts/controllers/network/createInfuraClient.test.js @@ -2,7 +2,10 @@ * @jest-environment node */ -import { withInfuraClient } from './provider-api-tests/helpers'; +import { + withMockedInfuraCommunications, + withInfuraClient, +} from './provider-api-tests/helpers'; import { testsForRpcMethodNotHandledByMiddleware, testsForRpcMethodAssumingNoBlockParam, @@ -141,9 +144,36 @@ describe('createInfuraClient', () => { }); describe('eth_getTransactionByHash', () => { - testsForRpcMethodsThatCheckForBlockHashInResponse( - 'eth_getTransactionByHash', - ); + const method = 'eth_getTransactionByHash'; + + testsForRpcMethodsThatCheckForBlockHashInResponse(method); + + it("refreshes the block tracker's current block if it is less than the block number that comes back in the response", async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest + // block number is retrieved through the block tracker first. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // This is our request. + comms.mockInfuraRpcCall({ + request, + response: { + result: { + blockNumber: '0x200', + }, + }, + }); + // The block-tracker-inspector middleware will request the latest + // block through the block tracker again. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x300' }); + + await withInfuraClient(async ({ makeRpcCall, blockTracker }) => { + await makeRpcCall(request); + expect(blockTracker.getCurrentBlock()).toStrictEqual('0x300'); + }); + }); + }); }); describe('eth_getTransactionCount', () => { @@ -153,9 +183,36 @@ describe('createInfuraClient', () => { }); describe('eth_getTransactionReceipt', () => { - testsForRpcMethodsThatCheckForBlockHashInResponse( - 'eth_getTransactionReceipt', - ); + const method = 'eth_getTransactionReceipt'; + + testsForRpcMethodsThatCheckForBlockHashInResponse(method); + + it("refreshes the block tracker's current block if it is less than the block number that comes back in the response", async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest + // block number is retrieved through the block tracker first. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // This is our request. + comms.mockInfuraRpcCall({ + request, + response: { + result: { + blockNumber: '0x200', + }, + }, + }); + // The block-tracker-inspector middleware will request the latest + // block through the block tracker again. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x300' }); + + await withInfuraClient(async ({ makeRpcCall, blockTracker }) => { + await makeRpcCall(request); + expect(blockTracker.getCurrentBlock()).toStrictEqual('0x300'); + }); + }); + }); }); describe('eth_getUncleByBlockHashAndIndex', () => { diff --git a/app/scripts/controllers/network/provider-api-tests/helpers.js b/app/scripts/controllers/network/provider-api-tests/helpers.js index 9b4c22460777..d49cdb7c2072 100644 --- a/app/scripts/controllers/network/provider-api-tests/helpers.js +++ b/app/scripts/controllers/network/provider-api-tests/helpers.js @@ -38,37 +38,37 @@ import createInfuraClient from '../createInfuraClient'; */ /** - * @typedef {{ nockScope: NockScope, blockNumber: string }} MockNextBlockTrackerRequestOptions + * @typedef {{ nockScope: NockScope, blockNumber: string }} MockBlockTrackerRequestOptions * - * The options to `mockNextBlockTrackerRequest`. + * The options to `mockNextBlockTrackerRequest` and `mockAllBlockTrackerRequests`. */ /** - * @typedef {{ nockScope: NockScope, request: object, response: object, delay?: number }} MockSuccessfulInfuraRpcCallOptions + * @typedef {{ nockScope: NockScope, request: object, response: object, delay?: number }} MockInfuraRpcCallOptions * - * The options to `mockSuccessfulInfuraRpcCall`. + * The options to `mockInfuraRpcCall`. */ /** - * @typedef {{mockNextBlockTrackerRequest: (options: Omit) => void, mockSuccessfulInfuraRpcCall: (options: Omit) => NockScope}} InfuraCommunications + * @typedef {{mockNextBlockTrackerRequest: (options: Omit) => void, mockAllBlockTrackerRequests: (options: Omit) => void, mockInfuraRpcCall: (options: Omit) => NockScope}} InfuraCommunications * * Provides methods to mock different kinds of requests to Infura. */ /** - * @typedef {{network: string}} MockingInfuraCommunicationsOptions + * @typedef {{network: string}} WithMockedInfuraCommunicationsOptions * * The options bag that `mockingInfuraCommunications` takes. */ /** - * @typedef {(comms: InfuraCommunications) => Promise} MockingInfuraCommunicationsCallback + * @typedef {(comms: InfuraCommunications) => Promise} WithMockedInfuraCommunicationsCallback * * The callback that `mockingInfuraCommunications` takes. */ /** - * @typedef {[MockingInfuraCommunicationsOptions, MockingInfuraCommunicationsCallback] | [MockingInfuraCommunicationsCallback]} MockingInfuraCommunicationsArgs + * @typedef {[WithMockedInfuraCommunicationsOptions, WithMockedInfuraCommunicationsCallback] | [WithMockedInfuraCommunicationsCallback]} WithMockedInfuraCommunicationsArgs * * The arguments to `mockingInfuraCommunications`. */ @@ -111,7 +111,7 @@ function buildScopeForMockingInfuraRequests({ network = 'mainnet' } = {}) { /** * Mocks the next request for the latest block that the block tracker will make. * - * @param {MockNextBlockTrackerRequestOptions} args - The arguments. + * @param {MockBlockTrackerRequestOptions} args - The arguments. * @param {NockScope} args.nockScope - A nock scope (a set of mocked requests * scoped to a certain base URL). * @param {string} args.blockNumber - The block number that the block tracker @@ -121,35 +121,80 @@ async function mockNextBlockTrackerRequest({ nockScope, blockNumber = DEFAULT_LATEST_BLOCK_NUMBER, }) { - await mockSuccessfulInfuraRpcCall({ + await mockInfuraRpcCall({ nockScope, request: { method: 'eth_blockNumber', params: [] }, response: { result: blockNumber }, }); } +/** + * Mocks all requests for the latest block that the block tracker will make. + * + * @param {MockBlockTrackerRequestOptions} args - The arguments. + * @param {NockScope} args.nockScope - A nock scope (a set of mocked requests + * scoped to a certain base URL). + * @param {string} args.blockNumber - The block number that the block tracker + * should report, as a 0x-prefixed hex string. + */ +async function mockAllBlockTrackerRequests({ + nockScope, + blockNumber = DEFAULT_LATEST_BLOCK_NUMBER, +}) { + await mockInfuraRpcCall({ + nockScope, + request: { method: 'eth_blockNumber', params: [] }, + response: { result: blockNumber }, + }).persist(); +} + /** * Mocks a JSON-RPC request sent to Infura with the given response. * - * @param {MockSuccessfulInfuraRpcCallOptions} args - The arguments. + * @param {MockInfuraRpcCallOptions} args - The arguments. * @param {NockScope} args.nockScope - A nock scope (a set of mocked requests * scoped to a certain base URL). * @param {object} args.request - The request data. - * @param {object} args.response - The response that the request should have. - * @param {number} args.delay - The amount of time that should pass before the + * @param {{body: string} | {httpStatus?: number; id?: number; method?: string; params?: string[]}} [args.response] - Information + * concerning the response that the request should have. If a `body` property is + * present, this is taken as the complete response body. If an `httpStatus` + * property is present, then it is taken as the HTTP status code to respond + * with. Properties other than these two are used to build a complete response + * body (including `id` and `jsonrpc` properties). + * @param {Error | string} [args.error] - An error to throw while making the + * request. Takes precedence over `response`. + * @param {number} [args.delay] - The amount of time that should pass before the * request resolves with the response. + * @param {number} [args.times] - The number of times that the request is + * expected to be made. * @returns {NockScope} The nock scope. */ -function mockSuccessfulInfuraRpcCall({ nockScope, request, response, delay }) { - // eth-query always passes `params`, so even if we don't supply this property +function mockInfuraRpcCall({ + nockScope, + request, + response, + error, + delay, + times, +}) { + // eth-query always passes `params`, so even if we don't supply this property, // for consistency with makeRpcCall, assume that the `body` contains it const { method, params = [], ...rest } = request; - const completeResponse = { - id: 1, - jsonrpc: '2.0', - ...response, - }; - const nockRequest = nockScope.post(`/v3/${INFURA_PROJECT_ID}`, { + const httpStatus = response?.httpStatus ?? 200; + let completeResponse; + if (response !== undefined) { + if (response.body === undefined) { + completeResponse = { id: 1, jsonrpc: '2.0' }; + ['id', 'jsonrpc', 'result', 'error'].forEach((prop) => { + if (response[prop] !== undefined) { + completeResponse[prop] = response[prop]; + } + }); + } else { + completeResponse = response.body; + } + } + let nockRequest = nockScope.post(`/v3/${INFURA_PROJECT_ID}`, { jsonrpc: '2.0', method, params, @@ -157,10 +202,19 @@ function mockSuccessfulInfuraRpcCall({ nockScope, request, response, delay }) { }); if (delay !== undefined) { - nockRequest.delay(delay); + nockRequest = nockRequest.delay(delay); + } + + if (times !== undefined) { + nockRequest = nockRequest.times(times); } - return nockRequest.reply(200, completeResponse); + if (error !== undefined) { + return nockRequest.replyWithError(error); + } else if (completeResponse !== undefined) { + return nockRequest.reply(httpStatus, completeResponse); + } + return nockRequest; } /** @@ -189,7 +243,7 @@ function makeRpcCall(ethQuery, request) { /** * Sets up request mocks for requests to Infura. * - * @param {MockingInfuraCommunicationsArgs} args - Either an options bag + a + * @param {WithMockedInfuraCommunicationsArgs} args - Either an options bag + a * function, or just a function. The options bag, at the moment, may contain * `network` (that is, the Infura network; defaults to "mainnet"). The function * is called with an object that allows you to mock different kinds of requests. @@ -202,11 +256,14 @@ export async function withMockedInfuraCommunications(...args) { const nockScope = buildScopeForMockingInfuraRequests({ network }); const curriedMockNextBlockTrackerRequest = (localOptions) => mockNextBlockTrackerRequest({ nockScope, ...localOptions }); - const curriedMockSuccessfulInfuraRpcCall = (localOptions) => - mockSuccessfulInfuraRpcCall({ nockScope, ...localOptions }); + const curriedMockAllBlockTrackerRequests = (localOptions) => + mockAllBlockTrackerRequests({ nockScope, ...localOptions }); + const curriedMockInfuraRpcCall = (localOptions) => + mockInfuraRpcCall({ nockScope, ...localOptions }); const comms = { mockNextBlockTrackerRequest: curriedMockNextBlockTrackerRequest, - mockSuccessfulInfuraRpcCall: curriedMockSuccessfulInfuraRpcCall, + mockAllBlockTrackerRequests: curriedMockAllBlockTrackerRequests, + mockInfuraRpcCall: curriedMockInfuraRpcCall, }; try { @@ -258,9 +315,10 @@ export async function withInfuraClient(...args) { // depends on `setTimeout`) const clock = sinon.useFakeTimers(); const client = { + blockTracker, + clock, makeRpcCall: curriedMakeRpcCall, makeRpcCallsInSeries, - clock, }; try { diff --git a/app/scripts/controllers/network/provider-api-tests/shared-tests.js b/app/scripts/controllers/network/provider-api-tests/shared-tests.js index aafa2155a9b1..c28855435a55 100644 --- a/app/scripts/controllers/network/provider-api-tests/shared-tests.js +++ b/app/scripts/controllers/network/provider-api-tests/shared-tests.js @@ -9,6 +9,57 @@ import { buildRequestWithReplacedBlockParam, } from './helpers'; +const originalSetTimeout = setTimeout; + +/** + * Some middleware contain logic which retries the request if some condition + * applies. This retrying always happens out of band via `setTimeout`, and + * because we are stubbing time via Jest's fake timers, we have to manually + * advance the clock so that the `setTimeout` handlers get fired. We don't know + * when these timers will get created, however, so we have to keep advancing + * timers until the request has been made an appropriate number of times. + * Unfortunately we don't have a good way to know how many times a request has + * been retried, but the good news is that the middleware won't end, and thus + * the promise which the RPC call returns won't get fulfilled, until all retries + * have been made. + * + * @param promise - The promise which is returned by the RPC call. + * @param clock - A Sinon clock object which can be used to advance to the next + * `setTimeout` handler. + */ +async function waitForPromiseToBeFulfilledAfterRunningAllTimers( + promise, + clock, +) { + let hasPromiseBeenFulfilled = false; + let numTimesClockHasBeenAdvanced = 0; + + promise + .catch(() => { + // This is used to silence Node.js warnings about the rejection + // being handled asynchronously. The error is handled later when + // `promise` is awaited. + }) + .finally(() => { + hasPromiseBeenFulfilled = true; + }); + + // `isPromiseFulfilled` is modified asynchronously. + /* eslint-disable-next-line no-unmodified-loop-condition */ + while (!hasPromiseBeenFulfilled && numTimesClockHasBeenAdvanced < 15) { + clock.runAll(); + await new Promise((resolve) => originalSetTimeout(resolve, 10)); + numTimesClockHasBeenAdvanced += 1; + } + + return promise; +} + +/** + * Defines tests which exercise the behavior exhibited by an RPC method that + * does not support params (which affects how the method is cached). + */ +/* eslint-disable-next-line jest/no-export */ export function testsForRpcMethodNotHandledByMiddleware( method, { numberOfParameters }, @@ -25,7 +76,7 @@ export function testsForRpcMethodNotHandledByMiddleware( // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request, response: { result: expectedResult }, }); @@ -55,7 +106,7 @@ export function testsForRpcMethodAssumingNoBlockParam(method) { // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); @@ -78,12 +129,12 @@ export function testsForRpcMethodAssumingNoBlockParam(method) { // the second RPC request, but rather because we call `clock.runAll()` // below. comms.mockNextBlockTrackerRequest({ blockNumber: '0x1' }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); comms.mockNextBlockTrackerRequest({ blockNumber: '0x2' }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -112,11 +163,11 @@ export function testsForRpcMethodAssumingNoBlockParam(method) { // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -129,6 +180,265 @@ export function testsForRpcMethodAssumingNoBlockParam(method) { }); }, ); + + it('queues requests while a previous identical call is still pending, then runs the queue when it finishes, reusing the result from the first request', async () => { + const requests = [{ method }, { method }, { method }]; + const mockResults = ['first result', 'second result', 'third result']; + + await withMockedInfuraCommunications(async (comms) => { + // The first time a block-cacheable request is made, the latest block + // number is retrieved through the block tracker first. It doesn't + // matter what this is — it's just used as a cache key. + comms.mockNextBlockTrackerRequest(); + comms.mockInfuraRpcCall({ + request: requests[0], + response: { result: mockResults[0] }, + delay: 100, + }); + comms.mockInfuraRpcCall({ + request: requests[1], + response: { result: mockResults[1] }, + }); + comms.mockInfuraRpcCall({ + request: requests[2], + response: { result: mockResults[2] }, + }); + + const results = await withInfuraClient(async (client) => { + const resultPromises = [ + client.makeRpcCall(requests[0]), + client.makeRpcCall(requests[1]), + client.makeRpcCall(requests[2]), + ]; + const firstResult = await resultPromises[0]; + // The inflight cache middleware uses setTimeout to run the handlers, + // so run them now + client.clock.runAll(); + const remainingResults = await Promise.all(resultPromises.slice(1)); + return [firstResult, ...remainingResults]; + }); + + expect(results).toStrictEqual([ + mockResults[0], + mockResults[0], + mockResults[0], + ]); + }); + }); + + it('throws a custom error if the request to Infura returns a 405 response', async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest block + // number is retrieved through the block tracker first. It doesn't + // matter what this is — it's just used as a cache key. + comms.mockNextBlockTrackerRequest(); + comms.mockInfuraRpcCall({ + request, + response: { + httpStatus: 405, + }, + }); + const promiseForResult = withInfuraClient(async ({ makeRpcCall }) => + makeRpcCall(request), + ); + + await expect(promiseForResult).rejects.toThrow( + 'The method does not exist / is not available', + ); + }); + }); + + it('throws a custom error if the request to Infura returns a 429 response', async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest block + // number is retrieved through the block tracker first. It doesn't + // matter what this is — it's just used as a cache key. + comms.mockNextBlockTrackerRequest(); + comms.mockInfuraRpcCall({ + request, + response: { + httpStatus: 429, + }, + }); + const promiseForResult = withInfuraClient(async ({ makeRpcCall }) => + makeRpcCall(request), + ); + + await expect(promiseForResult).rejects.toThrow( + 'Request is being rate limited', + ); + }); + }); + + it('throws a custom error if the request to Infura returns a response that is not 405, 429, 503, or 504', async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest block + // number is retrieved through the block tracker first. It doesn't + // matter what this is — it's just used as a cache key. + comms.mockNextBlockTrackerRequest(); + comms.mockInfuraRpcCall({ + request, + response: { + id: 12345, + jsonrpc: '2.0', + error: 'some error', + httpStatus: 420, + }, + }); + const promiseForResult = withInfuraClient(async ({ makeRpcCall }) => + makeRpcCall(request), + ); + + await expect(promiseForResult).rejects.toThrow( + '{"id":12345,"jsonrpc":"2.0","error":"some error"}', + ); + }); + }); + + [503, 504].forEach((httpStatus) => { + it(`retries the request to Infura up to 5 times if it returns a ${httpStatus} response, returning the successful result if there is one on the 5th try`, async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest block + // number is retrieved through the block tracker first. It doesn't + // matter what this is — it's just used as a cache key. + comms.mockNextBlockTrackerRequest(); + // Here we have the request fail for the first 4 tries, then succeed + // on the 5th try. + comms.mockInfuraRpcCall({ + request, + response: { + error: 'Some error', + httpStatus, + }, + times: 4, + }); + comms.mockInfuraRpcCall({ + request, + response: { + result: 'the result', + httpStatus: 200, + }, + }); + const result = await withInfuraClient( + async ({ makeRpcCall, clock }) => { + return await waitForPromiseToBeFulfilledAfterRunningAllTimers( + makeRpcCall(request), + clock, + ); + }, + ); + + expect(result).toStrictEqual('the result'); + }); + }); + + it(`causes a request to fail with a custom error if the request to Infura returns a ${httpStatus} response 5 times in a row`, async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest block + // number is retrieved through the block tracker first. It doesn't + // matter what this is — it's just used as a cache key. + comms.mockNextBlockTrackerRequest(); + comms.mockInfuraRpcCall({ + request, + response: { + error: 'Some error', + httpStatus, + }, + times: 5, + }); + const promiseForResult = withInfuraClient( + async ({ makeRpcCall, clock }) => { + return await waitForPromiseToBeFulfilledAfterRunningAllTimers( + makeRpcCall(request), + clock, + ); + }, + ); + + await expect(promiseForResult).rejects.toThrow( + /^InfuraProvider - cannot complete request\. All retries exhausted\..+Gateway timeout/su, + ); + }); + }); + }); + + ['ETIMEDOUT', 'ECONNRESET', 'SyntaxError'].forEach((errorMessagePrefix) => { + it(`retries the request to Infura up to 5 times if an "${errorMessagePrefix}" error is thrown while making the request, returning the successful result if there is one on the 5th try`, async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest block + // number is retrieved through the block tracker first. It doesn't + // matter what this is — it's just used as a cache key. + comms.mockNextBlockTrackerRequest(); + // Here we have the request fail for the first 4 tries, then succeed + // on the 5th try. + comms.mockInfuraRpcCall({ + request, + error: `${errorMessagePrefix}: Some message`, + times: 4, + }); + comms.mockInfuraRpcCall({ + request, + response: { + result: 'the result', + httpStatus: 200, + }, + }); + const result = await withInfuraClient( + async ({ makeRpcCall, clock }) => { + return await waitForPromiseToBeFulfilledAfterRunningAllTimers( + makeRpcCall(request), + clock, + ); + }, + ); + + expect(result).toStrictEqual('the result'); + }); + }); + + it(`causes a request to fail with a custom error if an "${errorMessagePrefix}" error is thrown while making the request to Infura 5 times in a row`, async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the latest block + // number is retrieved through the block tracker first. It doesn't + // matter what this is — it's just used as a cache key. + comms.mockNextBlockTrackerRequest(); + comms.mockInfuraRpcCall({ + request, + error: `${errorMessagePrefix}: Some message`, + times: 5, + }); + const promiseForResult = withInfuraClient( + async ({ makeRpcCall, clock }) => { + return await waitForPromiseToBeFulfilledAfterRunningAllTimers( + makeRpcCall(request), + clock, + ); + }, + ); + + await expect(promiseForResult).rejects.toThrow( + new RegExp( + `^InfuraProvider - cannot complete request\\. All retries exhausted\\..+${errorMessagePrefix}: Some message`, + 'su', + ), + ); + }); + }); + }); } /** @@ -148,7 +458,7 @@ export function testsForRpcMethodsThatCheckForBlockHashInResponse(method) { // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); @@ -172,12 +482,12 @@ export function testsForRpcMethodsThatCheckForBlockHashInResponse(method) { // because of the second RPC request, but rather because we call // `clock.runAll()` below. comms.mockNextBlockTrackerRequest({ blockNumber: '0x1' }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); comms.mockNextBlockTrackerRequest({ blockNumber: '0x2' }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -206,11 +516,11 @@ export function testsForRpcMethodsThatCheckForBlockHashInResponse(method) { // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -219,6 +529,7 @@ export function testsForRpcMethodsThatCheckForBlockHashInResponse(method) { makeRpcCallsInSeries(requests), ); + // TODO: Does this work? expect(results).toStrictEqual(mockResults); }); }, @@ -236,11 +547,11 @@ export function testsForRpcMethodsThatCheckForBlockHashInResponse(method) { // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -265,11 +576,11 @@ export function testsForRpcMethodsThatCheckForBlockHashInResponse(method) { // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -298,11 +609,11 @@ export function testsForRpcMethodsThatCheckForBlockHashInResponse(method) { // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -354,7 +665,7 @@ export function testsForRpcMethodSupportingBlockParam( // The block-ref middleware will make the request as specified // except that the block param is replaced with the latest block // number. - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: buildRequestWithReplacedBlockParam( requests[0], blockParamIndex, @@ -364,7 +675,7 @@ export function testsForRpcMethodSupportingBlockParam( }); // Note that the block-ref middleware will still allow the original // request to go through. - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); @@ -394,7 +705,7 @@ export function testsForRpcMethodSupportingBlockParam( // The block-ref middleware will make the request as specified // except that the block param is replaced with the latest block // number. - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: buildRequestWithReplacedBlockParam( requests[0], blockParamIndex, @@ -404,18 +715,18 @@ export function testsForRpcMethodSupportingBlockParam( }); // Note that the block-ref middleware will still allow the original // request to go through. - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); comms.mockNextBlockTrackerRequest({ blockNumber: '0x200' }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); // The previous two requests will happen again, with a different block // number, in the same order. - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: buildRequestWithReplacedBlockParam( requests[0], blockParamIndex, @@ -423,7 +734,7 @@ export function testsForRpcMethodSupportingBlockParam( ), response: { result: mockResults[1] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[1] }, }); @@ -461,7 +772,7 @@ export function testsForRpcMethodSupportingBlockParam( // The block-ref middleware will make the request as specified // except that the block param is replaced with the latest block // number. - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: buildRequestWithReplacedBlockParam( requests[0], blockParamIndex, @@ -471,12 +782,12 @@ export function testsForRpcMethodSupportingBlockParam( }); // Note that the block-ref middleware will still allow the original // request to go through. - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); // The previous two requests will happen again, in the same order. - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: buildRequestWithReplacedBlockParam( requests[0], blockParamIndex, @@ -484,7 +795,7 @@ export function testsForRpcMethodSupportingBlockParam( ), response: { result: mockResults[1] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[1] }, }); @@ -497,6 +808,420 @@ export function testsForRpcMethodSupportingBlockParam( }); }, ); + + it('queues requests while a previous identical call is still pending, then runs the queue when it finishes, reusing the result from the first request', async () => { + const requests = [{ method }, { method }, { method }]; + const mockResults = ['first result', 'second result', 'third result']; + + await withMockedInfuraCommunications(async (comms) => { + // The first time a block-cacheable request is made, the + // block-cache middleware will request the latest block number + // through the block tracker to determine the cache key. Later, + // the block-ref middleware will request the latest block number + // again to resolve the value of "latest", but the block number is + // cached once made, so we only need to mock the request once. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The block-ref middleware will make the request as specified + // except that the block param is replaced with the latest block + // number. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + requests[0], + blockParamIndex, + '0x100', + ), + response: { result: mockResults[0] }, + }); + // This is the original request as below, which the block-ref + // middleware will allow through, except that we delay it. + comms.mockInfuraRpcCall({ + request: requests[0], + response: { result: mockResults[0] }, + delay: 100, + }); + // The previous two requests will happen again, in the same order. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + requests[1], + blockParamIndex, + '0x100', + ), + response: { result: mockResults[1] }, + }); + comms.mockInfuraRpcCall({ + request: requests[1], + response: { result: mockResults[1] }, + }); + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + requests[2], + blockParamIndex, + '0x100', + ), + response: { result: mockResults[2] }, + }); + comms.mockInfuraRpcCall({ + request: requests[2], + response: { result: mockResults[2] }, + }); + + const results = await withInfuraClient(async (client) => { + const resultPromises = [ + client.makeRpcCall(requests[0]), + client.makeRpcCall(requests[1]), + client.makeRpcCall(requests[2]), + ]; + const firstResult = await resultPromises[0]; + // The inflight cache middleware uses setTimeout to run the + // handlers, so run them now + client.clock.runAll(); + const remainingResults = await Promise.all(resultPromises.slice(1)); + return [firstResult, ...remainingResults]; + }); + + expect(results).toStrictEqual([ + mockResults[0], + mockResults[0], + mockResults[0], + ]); + }); + }); + + if (blockParamType === 'none') { + it('throws a custom error if the request to Infura returns a 405 response', async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the + // block-cache middleware will request the latest block number + // through the block tracker to determine the cache key. Later, + // the block-ref middleware will request the latest block number + // again to resolve the value of "latest", but the block number is + // cached once made, so we only need to mock the request once. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The block-ref middleware will make the request as specified + // except that the block param is replaced with the latest block + // number. + // + // Note, however, that the block-ref middleware doesn't run the + // original request, as it fails before it gets to that point, so + // there is no need to mock the request again. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + response: { + httpStatus: 405, + }, + }); + const promiseForResult = withInfuraClient(async ({ makeRpcCall }) => + makeRpcCall(request), + ); + + await expect(promiseForResult).rejects.toThrow( + 'The method does not exist / is not available', + ); + }); + }); + + it('throws a custom error if the request to Infura returns a 429 response', async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the + // block-cache middleware will request the latest block number + // through the block tracker to determine the cache key. Later, + // the block-ref middleware will request the latest block number + // again to resolve the value of "latest", but the block number is + // cached once made, so we only need to mock the request once. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The block-ref middleware will make the request as specified + // except that the block param is replaced with the latest block + // number. + // + // Note, however, that the block-ref middleware doesn't run the + // original request, as it fails before it gets to that point, so + // there is no need to mock the request again. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + response: { + httpStatus: 429, + }, + }); + const promiseForResult = withInfuraClient(async ({ makeRpcCall }) => + makeRpcCall(request), + ); + + await expect(promiseForResult).rejects.toThrow( + 'Request is being rate limited', + ); + }); + }); + + it('throws a custom error if the request to Infura returns a response that is not 405, 429, 503, or 504', async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the + // block-cache middleware will request the latest block number + // through the block tracker to determine the cache key. Later, + // the block-ref middleware will request the latest block number + // again to resolve the value of "latest", but the block number is + // cached once made, so we only need to mock the request once. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The block-ref middleware will make the request as specified + // except that the block param is replaced with the latest block + // number. + // + // Note, however, that the block-ref middleware doesn't run the + // original request, as it fails before it gets to that point, so + // there is no need to mock the request again. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + response: { + id: 12345, + jsonrpc: '2.0', + error: 'some error', + httpStatus: 420, + }, + }); + const promiseForResult = withInfuraClient(async ({ makeRpcCall }) => + makeRpcCall(request), + ); + + await expect(promiseForResult).rejects.toThrow( + '{"id":12345,"jsonrpc":"2.0","error":"some error"}', + ); + }); + }); + + [503, 504].forEach((httpStatus) => { + it(`retries the request to Infura up to 5 times if it returns a ${httpStatus} response, returning the successful result if there is one on the 5th try`, async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the + // block-cache middleware will request the latest block number + // through the block tracker to determine the cache key. Later, + // the block-ref middleware will request the latest block number + // again to resolve the value of "latest", but the block number is + // cached once made, so we only need to mock the request once. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The block-ref middleware will make the request as specified + // except that the block param is replaced with the latest block + // number. + // + // Here we have the request fail for the first 4 tries, then succeed + // on the 5th try. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + response: { + error: 'some error', + httpStatus, + }, + times: 4, + }); + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + response: { + result: 'the result', + httpStatus: 200, + }, + }); + // Note that the block-ref middleware will still allow the original + // request to go through. + comms.mockInfuraRpcCall({ + request, + response: { + result: 'the result', + httpStatus: 200, + }, + }); + const result = await withInfuraClient( + async ({ makeRpcCall, clock }) => { + return await waitForPromiseToBeFulfilledAfterRunningAllTimers( + makeRpcCall(request), + clock, + ); + }, + ); + + expect(result).toStrictEqual('the result'); + }); + }); + + it(`causes a request to fail with a custom error if the request to Infura returns a ${httpStatus} response 5 times in a row`, async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the + // block-cache middleware will request the latest block number + // through the block tracker to determine the cache key. Later, + // the block-ref middleware will request the latest block number + // again to resolve the value of "latest", but the block number is + // cached once made, so we only need to mock the request once. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The block-ref middleware will make the request as specified + // except that the block param is replaced with the latest block + // number. + // + // Note, however, that the block-ref middleware doesn't run the + // original request, as it fails before it gets to that point, so + // there is no need to mock the request again. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + response: { + error: 'Some error', + httpStatus, + }, + times: 5, + }); + const promiseForResult = withInfuraClient( + async ({ makeRpcCall, clock }) => { + return await waitForPromiseToBeFulfilledAfterRunningAllTimers( + makeRpcCall(request), + clock, + ); + }, + ); + + await expect(promiseForResult).rejects.toThrow( + /^InfuraProvider - cannot complete request\. All retries exhausted\..+Gateway timeout/su, + ); + }); + }); + }); + + ['ETIMEDOUT', 'ECONNRESET', 'SyntaxError'].forEach( + (errorMessagePrefix) => { + it(`retries the request to Infura up to 5 times if an "${errorMessagePrefix}" error is thrown while making the request, returning the successful result if there is one on the 5th try`, async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the + // block-cache middleware will request the latest block number + // through the block tracker to determine the cache key. Later, + // the block-ref middleware will request the latest block number + // again to resolve the value of "latest", but the block number is + // cached once made, so we only need to mock the request once. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The block-ref middleware will make the request as specified + // except that the block param is replaced with the latest block + // number. + // + // Here we have the request fail for the first 4 tries, then + // succeed on the 5th try. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + error: `${errorMessagePrefix}: Some message`, + times: 4, + }); + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + response: { + result: 'the result', + httpStatus: 200, + }, + }); + // Note that the block-ref middleware will still allow the + // original request to go through. + comms.mockInfuraRpcCall({ + request, + response: { + result: 'the result', + httpStatus: 200, + }, + }); + const result = await withInfuraClient( + async ({ makeRpcCall, clock }) => { + return await waitForPromiseToBeFulfilledAfterRunningAllTimers( + makeRpcCall(request), + clock, + ); + }, + ); + + expect(result).toStrictEqual('the result'); + }); + }); + + it(`causes a request to fail with a custom error if an "${errorMessagePrefix}" error is thrown while making the request to Infura 5 times in a row`, async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { method }; + + // The first time a block-cacheable request is made, the + // block-cache middleware will request the latest block number + // through the block tracker to determine the cache key. Later, + // the block-ref middleware will request the latest block number + // again to resolve the value of "latest", but the block number is + // cached once made, so we only need to mock the request once. + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The block-ref middleware will make the request as specified + // except that the block param is replaced with the latest block + // number. + // + // Note, however, that the block-ref middleware doesn't run the + // original request, as it fails before it gets to that point, so + // there is no need to mock the request again. + comms.mockInfuraRpcCall({ + request: buildRequestWithReplacedBlockParam( + request, + blockParamIndex, + '0x100', + ), + error: `${errorMessagePrefix}: Some message`, + times: 5, + }); + const promiseForResult = withInfuraClient( + async ({ makeRpcCall, clock }) => { + return await waitForPromiseToBeFulfilledAfterRunningAllTimers( + makeRpcCall(request), + clock, + ); + }, + ); + + await expect(promiseForResult).rejects.toThrow( + new RegExp( + `^InfuraProvider - cannot complete request\\. All retries exhausted\\..+${errorMessagePrefix}: Some message`, + 'su', + ), + ); + }); + }); + }, + ); + } }); describe.each([ @@ -518,7 +1243,7 @@ export function testsForRpcMethodSupportingBlockParam( // tracker to determine the cache key. This block number doesn't // matter. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); @@ -545,12 +1270,12 @@ export function testsForRpcMethodSupportingBlockParam( // occur because of the second RPC request, but rather because we // call `clock.runAll()` below. comms.mockNextBlockTrackerRequest({ blockNumber: '0x1' }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); comms.mockNextBlockTrackerRequest({ blockNumber: '0x2' }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -582,11 +1307,11 @@ export function testsForRpcMethodSupportingBlockParam( // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); @@ -622,7 +1347,7 @@ export function testsForRpcMethodSupportingBlockParam( // block number is retrieved through the block tracker first. It // doesn't matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); @@ -654,11 +1379,11 @@ export function testsForRpcMethodSupportingBlockParam( // number is retrieved through the block tracker first. It doesn't // matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: 'first result' }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: 'second result' }, }); @@ -670,6 +1395,70 @@ export function testsForRpcMethodSupportingBlockParam( expect(results).toStrictEqual(['first result', 'second result']); }); }); + + it('makes an additional request to Infura if the given block number matches the latest block number', async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { + method, + params: buildMockParamsWithBlockParamAt(blockParamIndex, '0x100'), + }; + + // The first time a block-cacheable request is made, the latest + // block number is retrieved through the block tracker first. This + // also happens within the retry-on-empty middleware (although the + // latest block is cached by now). + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The retry-on-empty middleware will make an explicit request. + comms.mockInfuraRpcCall({ + request, + response: { result: 'this result gets overwritten' }, + }); + // Note that the retry-on-empty middleware will still allow the + // original request to go through. + comms.mockInfuraRpcCall({ + request, + response: { result: 'the actual result' }, + }); + + const result = await withInfuraClient(({ makeRpcCall }) => + makeRpcCall(request), + ); + + expect(result).toStrictEqual('the actual result'); + }); + }); + + it('makes an additional request to Infura if the given block number is less than the latest block number', async () => { + await withMockedInfuraCommunications(async (comms) => { + const request = { + method, + params: buildMockParamsWithBlockParamAt(blockParamIndex, '0x50'), + }; + + // The first time a block-cacheable request is made, the latest + // block number is retrieved through the block tracker first. This + // also happens within the retry-on-empty middleware (although the + // latest block is cached by now). + comms.mockNextBlockTrackerRequest({ blockNumber: '0x100' }); + // The retry-on-empty middleware will make an explicit request. + comms.mockInfuraRpcCall({ + request, + response: { result: 'this result gets overwritten' }, + }); + // Note that the retry-on-empty middleware will still allow the + // original request to go through. + comms.mockInfuraRpcCall({ + request, + response: { result: 'the actual result' }, + }); + + const result = await withInfuraClient(({ makeRpcCall }) => + makeRpcCall(request), + ); + + expect(result).toStrictEqual('the actual result'); + }); + }); } }); @@ -688,11 +1477,11 @@ export function testsForRpcMethodSupportingBlockParam( // block number is retrieved through the block tracker first. It // doesn't matter what this is — it's just used as a cache key. comms.mockNextBlockTrackerRequest(); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[0], response: { result: mockResults[0] }, }); - comms.mockSuccessfulInfuraRpcCall({ + comms.mockInfuraRpcCall({ request: requests[1], response: { result: mockResults[1] }, }); diff --git a/jest.config.js b/jest.config.js index 04b26dfe6519..1c8cfe7ff033 100644 --- a/jest.config.js +++ b/jest.config.js @@ -49,7 +49,7 @@ module.exports = { '/app/scripts/lib/**/*.test.js', '/app/scripts/migrations/*.test.js', '/app/scripts/platforms/*.test.js', - 'app/scripts/controllers/network/**/*.test.js', + '/app/scripts/controllers/network/**/*.test.js', '/app/scripts/controllers/permissions/**/*.test.js', '/app/scripts/flask/**/*.test.js', '/app/scripts/lib/createRPCMethodTrackingMiddleware.test.js', diff --git a/lavamoat/browserify/beta/policy.json b/lavamoat/browserify/beta/policy.json index fc15ef26bab5..2e1e455bc59c 100644 --- a/lavamoat/browserify/beta/policy.json +++ b/lavamoat/browserify/beta/policy.json @@ -288,7 +288,7 @@ "browserify>insert-module-globals>is-buffer": true, "browserify>timers-browserify": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs-mini": { @@ -388,7 +388,7 @@ "3box>ipfs>multibase": true, "browserify>assert": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>dlv": { @@ -450,7 +450,7 @@ "browserify>assert": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-bitswap>bignumber.js": { @@ -520,7 +520,7 @@ "browserify>assert": true, "browserify>browser-resolve": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-mfs>hamt-sharding": { @@ -567,7 +567,7 @@ "browserify>path-browserify": true, "browserify>timers-browserify": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-repo>bignumber.js": { @@ -811,7 +811,7 @@ "3box>ipfs>protons": true, "base32-encode": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>is-ipfs": { @@ -850,7 +850,7 @@ "browserify>insert-module-globals>is-buffer": true, "browserify>process": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -866,7 +866,7 @@ "3box>ipfs>peer-info": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p-crypto": { @@ -979,7 +979,7 @@ "browserify>events": true, "browserify>insert-module-globals>is-buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "promise-to-callback": true } }, @@ -1102,7 +1102,7 @@ "browserify>assert": true, "browserify>buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1161,7 +1161,7 @@ "3box>ipfs>stream-to-pull-stream": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1177,7 +1177,7 @@ "3box>ipfs>libp2p-webrtc-star>simple-peer>readable-stream": true, "browserify>buffer": true, "ethereumjs-wallet>randombytes": true, - "madge>debug": true, + "nock>debug": true, "pumpify>inherits": true } }, @@ -1377,7 +1377,7 @@ "3box>ipfs>multiaddr": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1399,7 +1399,7 @@ "browserify>buffer": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true, "uuid": true } @@ -1449,7 +1449,7 @@ "3box>ipfs>multiaddr-to-uri": true, "3box>ipfs>pull-mplex>interface-connection": true, "browserify>os-browserify": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p-websockets>pull-ws": { @@ -1478,7 +1478,7 @@ "packages": { "3box>ipfs>libp2p>libp2p-connection-manager>latency-monitor": true, "browserify>events": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-connection-manager>latency-monitor": { @@ -1518,7 +1518,7 @@ "3box>ipfs>pull-stream": true, "browserify>assert": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-floodsub>libp2p-pubsub": { @@ -1535,7 +1535,7 @@ "browserify>events": true, "browserify>insert-module-globals>is-buffer": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-floodsub>libp2p-pubsub>time-cache": { @@ -1555,7 +1555,7 @@ "3box>ipfs>libp2p-secio>pull-handshake": true, "3box>ipfs>pull-stream": true, "browserify>events": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-switch": { @@ -1578,7 +1578,7 @@ "browserify>assert": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1601,7 +1601,7 @@ "3box>ipfs>pull-stream": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1631,7 +1631,7 @@ "browserify>assert": true, "browserify>buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1806,7 +1806,7 @@ "browserify>buffer": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>pull-mplex>interface-connection": { @@ -2405,36 +2405,13 @@ }, "@keystonehq/bc-ur-registry-eth": { "packages": { - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": true, "@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry": true, "@keystonehq/bc-ur-registry-eth>hdkey": true, "browserify>buffer": true, + "eth-lattice-keyring>@ethereumjs/util": true, "uuid": true } }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": { - "packages": { - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp": true, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography": true, - "browserify>buffer": true, - "browserify>insert-module-globals>is-buffer": true - } - }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp": { - "globals": { - "TextEncoder": true - } - }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography": { - "globals": { - "TextDecoder": true, - "crypto": true - }, - "packages": { - "@metamask/rpc-methods>@metamask/key-tree>@noble/hashes": true, - "@metamask/rpc-methods>@metamask/key-tree>@noble/secp256k1": true - } - }, "@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry": { "globals": { "define": true @@ -2481,10 +2458,10 @@ "packages": { "@ethereumjs/tx": true, "@keystonehq/bc-ur-registry-eth": true, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": true, "@keystonehq/bc-ur-registry-eth>hdkey": true, "@keystonehq/metamask-airgapped-keyring>@keystonehq/base-eth-keyring>rlp": true, "browserify>buffer": true, + "eth-lattice-keyring>@ethereumjs/util": true, "uuid": true } }, @@ -3102,7 +3079,7 @@ "packages": { "@metamask/eth-json-rpc-infura>@metamask/utils>superstruct": true, "eslint>fast-deep-equal": true, - "madge>debug": true + "nock>debug": true } }, "@metamask/eth-json-rpc-infura>eth-json-rpc-middleware": { @@ -3231,15 +3208,36 @@ }, "packages": { "@babel/runtime": true, + "@metamask/eth-token-tracker>deep-equal": true, "@metamask/eth-token-tracker>eth-block-tracker": true, "@metamask/eth-token-tracker>ethjs": true, "@metamask/eth-token-tracker>human-standard-token-abi": true, "ethjs-contract": true, "ethjs-query": true, - "nock>deep-equal": true, "safe-event-emitter": true } }, + "@metamask/eth-token-tracker>deep-equal": { + "packages": { + "@metamask/eth-token-tracker>deep-equal>is-arguments": true, + "@metamask/eth-token-tracker>deep-equal>is-date-object": true, + "enzyme>is-regex": true, + "enzyme>object-is": true, + "mocha>object.assign>object-keys": true, + "string.prototype.matchall>regexp.prototype.flags": true + } + }, + "@metamask/eth-token-tracker>deep-equal>is-arguments": { + "packages": { + "koa>is-generator-function>has-tostringtag": true, + "string.prototype.matchall>call-bind": true + } + }, + "@metamask/eth-token-tracker>deep-equal>is-date-object": { + "packages": { + "koa>is-generator-function>has-tostringtag": true + } + }, "@metamask/eth-token-tracker>eth-block-tracker": { "globals": { "clearTimeout": true, @@ -3404,14 +3402,6 @@ "crypto": true } }, - "@metamask/rpc-methods>@metamask/key-tree>@noble/secp256k1": { - "globals": { - "crypto": true - }, - "packages": { - "browserify>browser-resolve": true - } - }, "@metamask/smart-transactions-controller": { "globals": { "URLSearchParams": true, @@ -3690,7 +3680,7 @@ "browserify>buffer": true, "browserify>util": true, "gulp-dart-sass>lodash.clonedeep": true, - "madge>debug": true, + "nock>debug": true, "semver": true } }, @@ -3913,7 +3903,7 @@ "@truffle/codec>web3-utils": true, "@truffle/decoder>@truffle/source-map-utils": true, "@truffle/decoder>bn.js": true, - "madge>debug": true + "nock>debug": true } }, "@truffle/decoder>@truffle/source-map-utils": { @@ -3923,7 +3913,7 @@ "@truffle/decoder>@truffle/source-map-utils>@truffle/code-utils": true, "@truffle/decoder>@truffle/source-map-utils>json-pointer": true, "@truffle/decoder>@truffle/source-map-utils>node-interval-tree": true, - "madge>debug": true + "nock>debug": true } }, "@truffle/decoder>@truffle/source-map-utils>@truffle/code-utils": { @@ -4474,15 +4464,6 @@ "string.prototype.matchall>call-bind": true } }, - "enzyme>object-inspect": { - "globals": { - "HTMLElement": true, - "WeakRef": true - }, - "packages": { - "browserify>browser-resolve": true - } - }, "enzyme>object-is": { "packages": { "globalthis>define-properties": true, @@ -4516,7 +4497,7 @@ "packages": { "eslint>fast-deep-equal": true, "eth-block-tracker>@metamask/utils>superstruct": true, - "madge>debug": true + "nock>debug": true } }, "eth-ens-namehash": { @@ -4586,7 +4567,7 @@ "packages": { "eslint>fast-deep-equal": true, "eth-json-rpc-middleware>@metamask/utils>superstruct": true, - "madge>debug": true + "nock>debug": true } }, "eth-json-rpc-middleware>eth-sig-util": { @@ -4740,44 +4721,56 @@ "clearInterval": true, "fetch": true, "open": true, - "setInterval": true, - "txData.type": true + "setInterval": true }, "packages": { "browserify>buffer": true, "browserify>crypto-browserify": true, "browserify>events": true, - "eth-lattice-keyring>@ethereumjs/common": true, "eth-lattice-keyring>@ethereumjs/tx": true, + "eth-lattice-keyring>@ethereumjs/util": true, "eth-lattice-keyring>bn.js": true, "eth-lattice-keyring>gridplus-sdk": true, - "eth-lattice-keyring>rlp": true, - "eth-lattice-keyring>secp256k1": true, - "ethereumjs-util": true + "eth-lattice-keyring>rlp": true } }, - "eth-lattice-keyring>@ethereumjs/common": { + "eth-lattice-keyring>@ethereumjs/tx": { "packages": { - "@ethereumjs/common>crc-32": true, + "@ethereumjs/common": true, "browserify>buffer": true, - "browserify>events": true, + "browserify>insert-module-globals>is-buffer": true, "ethereumjs-util": true } }, - "eth-lattice-keyring>@ethereumjs/tx": { + "eth-lattice-keyring>@ethereumjs/util": { "packages": { "browserify>buffer": true, "browserify>insert-module-globals>is-buffer": true, - "eth-lattice-keyring>@ethereumjs/tx>@ethereumjs/common": true, - "ethereumjs-util": true + "eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp": true, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography": true + } + }, + "eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp": { + "globals": { + "TextEncoder": true } }, - "eth-lattice-keyring>@ethereumjs/tx>@ethereumjs/common": { + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography": { + "globals": { + "TextDecoder": true, + "crypto": true + }, "packages": { - "@ethereumjs/common>crc-32": true, - "browserify>buffer": true, - "browserify>events": true, - "ethereumjs-util": true + "@metamask/rpc-methods>@metamask/key-tree>@noble/hashes": true, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/secp256k1": true + } + }, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/secp256k1": { + "globals": { + "crypto": true + }, + "packages": { + "browserify>browser-resolve": true } }, "eth-lattice-keyring>bn.js": { @@ -4790,9 +4783,15 @@ }, "eth-lattice-keyring>gridplus-sdk": { "globals": { + "AbortController": true, + "Request": true, "__values": true, + "caches": true, + "clearTimeout": true, + "console.error": true, "console.log": true, "console.warn": true, + "fetch": true, "setTimeout": true }, "packages": { @@ -4811,7 +4810,6 @@ "eth-lattice-keyring>gridplus-sdk>eth-eip712-util-browser": true, "eth-lattice-keyring>gridplus-sdk>rlp": true, "eth-lattice-keyring>gridplus-sdk>secp256k1": true, - "eth-lattice-keyring>gridplus-sdk>superagent": true, "ethereumjs-wallet>aes-js": true, "ethereumjs-wallet>bs58check": true, "ethers>@ethersproject/keccak256>js-sha3": true, @@ -4908,33 +4906,11 @@ "3box>ethers>elliptic": true } }, - "eth-lattice-keyring>gridplus-sdk>superagent": { - "globals": { - "XMLHttpRequest": true, - "btoa": true, - "clearTimeout": true, - "console.error": true, - "console.warn": true, - "setTimeout": true - }, - "packages": { - "browserify>browser-resolve": true, - "browserify>process": true, - "eth-rpc-errors>fast-safe-stringify": true, - "nock>qs": true, - "pubnub>superagent>component-emitter": true - } - }, "eth-lattice-keyring>rlp": { "globals": { "TextEncoder": true } }, - "eth-lattice-keyring>secp256k1": { - "packages": { - "3box>ethers>elliptic": true - } - }, "eth-method-registry": { "packages": { "ethjs": true @@ -4943,7 +4919,7 @@ "eth-query": { "packages": { "eth-query>json-rpc-random-id": true, - "madge>debug": true, + "nock>debug": true, "watchify>xtend": true } }, @@ -6683,7 +6659,7 @@ "globalthis>define-properties": { "packages": { "globalthis>define-properties>has-property-descriptors": true, - "nock>deep-equal>object-keys": true + "mocha>object.assign>object-keys": true } }, "globalthis>define-properties>has-property-descriptors": { @@ -6774,19 +6750,6 @@ "Intl": true } }, - "madge>debug": { - "globals": { - "console": true, - "document": true, - "localStorage": true, - "navigator": true, - "process": true - }, - "packages": { - "browserify>process": true, - "madge>debug>ms": true - } - }, "madge>rc>deep-extend": { "packages": { "browserify>buffer": true @@ -6822,30 +6785,17 @@ "navigator": true } }, - "nock>deep-equal": { - "packages": { - "enzyme>is-regex": true, - "enzyme>object-is": true, - "nock>deep-equal>is-arguments": true, - "nock>deep-equal>is-date-object": true, - "nock>deep-equal>object-keys": true, - "string.prototype.matchall>regexp.prototype.flags": true - } - }, - "nock>deep-equal>is-arguments": { - "packages": { - "koa>is-generator-function>has-tostringtag": true, - "string.prototype.matchall>call-bind": true - } - }, - "nock>deep-equal>is-date-object": { - "packages": { - "koa>is-generator-function>has-tostringtag": true - } - }, - "nock>qs": { + "nock>debug": { + "globals": { + "console": true, + "document": true, + "localStorage": true, + "navigator": true, + "process": true + }, "packages": { - "string.prototype.matchall>side-channel": true + "browserify>process": true, + "nock>debug>ms": true } }, "node-fetch": { @@ -7449,13 +7399,6 @@ "string.prototype.matchall>call-bind": true } }, - "string.prototype.matchall>side-channel": { - "packages": { - "enzyme>object-inspect": true, - "string.prototype.matchall>call-bind": true, - "string.prototype.matchall>get-intrinsic": true - } - }, "stylelint>write-file-atomic>typedarray-to-buffer": { "packages": { "browserify>buffer": true, diff --git a/lavamoat/browserify/flask/policy.json b/lavamoat/browserify/flask/policy.json index 8a8c07847d6a..6ba23b6c3f72 100644 --- a/lavamoat/browserify/flask/policy.json +++ b/lavamoat/browserify/flask/policy.json @@ -288,7 +288,7 @@ "browserify>insert-module-globals>is-buffer": true, "browserify>timers-browserify": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs-mini": { @@ -388,7 +388,7 @@ "3box>ipfs>multibase": true, "browserify>assert": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>dlv": { @@ -450,7 +450,7 @@ "browserify>assert": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-bitswap>bignumber.js": { @@ -520,7 +520,7 @@ "browserify>assert": true, "browserify>browser-resolve": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-mfs>hamt-sharding": { @@ -567,7 +567,7 @@ "browserify>path-browserify": true, "browserify>timers-browserify": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-repo>bignumber.js": { @@ -811,7 +811,7 @@ "3box>ipfs>protons": true, "base32-encode": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>is-ipfs": { @@ -850,7 +850,7 @@ "browserify>insert-module-globals>is-buffer": true, "browserify>process": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -866,7 +866,7 @@ "3box>ipfs>peer-info": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p-crypto": { @@ -979,7 +979,7 @@ "browserify>events": true, "browserify>insert-module-globals>is-buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "promise-to-callback": true } }, @@ -1102,7 +1102,7 @@ "browserify>assert": true, "browserify>buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1161,7 +1161,7 @@ "3box>ipfs>stream-to-pull-stream": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1177,7 +1177,7 @@ "3box>ipfs>libp2p-webrtc-star>simple-peer>readable-stream": true, "browserify>buffer": true, "ethereumjs-wallet>randombytes": true, - "madge>debug": true, + "nock>debug": true, "pumpify>inherits": true } }, @@ -1377,7 +1377,7 @@ "3box>ipfs>multiaddr": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1399,7 +1399,7 @@ "browserify>buffer": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true, "uuid": true } @@ -1449,7 +1449,7 @@ "3box>ipfs>multiaddr-to-uri": true, "3box>ipfs>pull-mplex>interface-connection": true, "browserify>os-browserify": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p-websockets>pull-ws": { @@ -1478,7 +1478,7 @@ "packages": { "3box>ipfs>libp2p>libp2p-connection-manager>latency-monitor": true, "browserify>events": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-connection-manager>latency-monitor": { @@ -1518,7 +1518,7 @@ "3box>ipfs>pull-stream": true, "browserify>assert": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-floodsub>libp2p-pubsub": { @@ -1535,7 +1535,7 @@ "browserify>events": true, "browserify>insert-module-globals>is-buffer": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-floodsub>libp2p-pubsub>time-cache": { @@ -1555,7 +1555,7 @@ "3box>ipfs>libp2p-secio>pull-handshake": true, "3box>ipfs>pull-stream": true, "browserify>events": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-switch": { @@ -1578,7 +1578,7 @@ "browserify>assert": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1601,7 +1601,7 @@ "3box>ipfs>pull-stream": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1631,7 +1631,7 @@ "browserify>assert": true, "browserify>buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1806,7 +1806,7 @@ "browserify>buffer": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>pull-mplex>interface-connection": { @@ -2218,7 +2218,7 @@ "browserify>path-browserify": true, "browserify>process": true, "depcheck>@babel/traverse": true, - "madge>debug": true, + "nock>debug": true, "nyc>convert-source-map": true } }, @@ -2566,36 +2566,13 @@ }, "@keystonehq/bc-ur-registry-eth": { "packages": { - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": true, "@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry": true, "@keystonehq/bc-ur-registry-eth>hdkey": true, "browserify>buffer": true, + "eth-lattice-keyring>@ethereumjs/util": true, "uuid": true } }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": { - "packages": { - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp": true, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography": true, - "browserify>buffer": true, - "browserify>insert-module-globals>is-buffer": true - } - }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp": { - "globals": { - "TextEncoder": true - } - }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography": { - "globals": { - "TextDecoder": true, - "crypto": true - }, - "packages": { - "@metamask/rpc-methods>@metamask/key-tree>@noble/hashes": true, - "@metamask/rpc-methods>@metamask/key-tree>@noble/secp256k1": true - } - }, "@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry": { "globals": { "define": true @@ -2642,10 +2619,10 @@ "packages": { "@ethereumjs/tx": true, "@keystonehq/bc-ur-registry-eth": true, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": true, "@keystonehq/bc-ur-registry-eth>hdkey": true, "@keystonehq/metamask-airgapped-keyring>@keystonehq/base-eth-keyring>rlp": true, "browserify>buffer": true, + "eth-lattice-keyring>@ethereumjs/util": true, "uuid": true } }, @@ -3263,7 +3240,7 @@ "packages": { "@metamask/eth-json-rpc-infura>@metamask/utils>superstruct": true, "eslint>fast-deep-equal": true, - "madge>debug": true + "nock>debug": true } }, "@metamask/eth-json-rpc-infura>eth-json-rpc-middleware": { @@ -3392,15 +3369,36 @@ }, "packages": { "@babel/runtime": true, + "@metamask/eth-token-tracker>deep-equal": true, "@metamask/eth-token-tracker>eth-block-tracker": true, "@metamask/eth-token-tracker>ethjs": true, "@metamask/eth-token-tracker>human-standard-token-abi": true, "ethjs-contract": true, "ethjs-query": true, - "nock>deep-equal": true, "safe-event-emitter": true } }, + "@metamask/eth-token-tracker>deep-equal": { + "packages": { + "@metamask/eth-token-tracker>deep-equal>is-arguments": true, + "@metamask/eth-token-tracker>deep-equal>is-date-object": true, + "enzyme>is-regex": true, + "enzyme>object-is": true, + "mocha>object.assign>object-keys": true, + "string.prototype.matchall>regexp.prototype.flags": true + } + }, + "@metamask/eth-token-tracker>deep-equal>is-arguments": { + "packages": { + "koa>is-generator-function>has-tostringtag": true, + "string.prototype.matchall>call-bind": true + } + }, + "@metamask/eth-token-tracker>deep-equal>is-date-object": { + "packages": { + "koa>is-generator-function>has-tostringtag": true + } + }, "@metamask/eth-token-tracker>eth-block-tracker": { "globals": { "clearTimeout": true, @@ -4468,7 +4466,7 @@ "browserify>buffer": true, "browserify>util": true, "gulp-dart-sass>lodash.clonedeep": true, - "madge>debug": true, + "nock>debug": true, "semver": true } }, @@ -4691,7 +4689,7 @@ "@truffle/codec>web3-utils": true, "@truffle/decoder>@truffle/source-map-utils": true, "@truffle/decoder>bn.js": true, - "madge>debug": true + "nock>debug": true } }, "@truffle/decoder>@truffle/source-map-utils": { @@ -4701,7 +4699,7 @@ "@truffle/decoder>@truffle/source-map-utils>@truffle/code-utils": true, "@truffle/decoder>@truffle/source-map-utils>json-pointer": true, "@truffle/decoder>@truffle/source-map-utils>node-interval-tree": true, - "madge>debug": true + "nock>debug": true } }, "@truffle/decoder>@truffle/source-map-utils>@truffle/code-utils": { @@ -5240,7 +5238,7 @@ "depcheck>@babel/traverse>@babel/helper-hoist-variables": true, "depcheck>@babel/traverse>@babel/helper-split-export-declaration": true, "depcheck>@babel/traverse>globals": true, - "madge>debug": true + "nock>debug": true } }, "depcheck>@babel/traverse>@babel/helper-function-name": { @@ -5286,15 +5284,6 @@ "string.prototype.matchall>call-bind": true } }, - "enzyme>object-inspect": { - "globals": { - "HTMLElement": true, - "WeakRef": true - }, - "packages": { - "browserify>browser-resolve": true - } - }, "enzyme>object-is": { "packages": { "globalthis>define-properties": true, @@ -5328,7 +5317,7 @@ "packages": { "eslint>fast-deep-equal": true, "eth-block-tracker>@metamask/utils>superstruct": true, - "madge>debug": true + "nock>debug": true } }, "eth-ens-namehash": { @@ -5398,7 +5387,7 @@ "packages": { "eslint>fast-deep-equal": true, "eth-json-rpc-middleware>@metamask/utils>superstruct": true, - "madge>debug": true + "nock>debug": true } }, "eth-json-rpc-middleware>eth-sig-util": { @@ -5552,44 +5541,56 @@ "clearInterval": true, "fetch": true, "open": true, - "setInterval": true, - "txData.type": true + "setInterval": true }, "packages": { "browserify>buffer": true, "browserify>crypto-browserify": true, "browserify>events": true, - "eth-lattice-keyring>@ethereumjs/common": true, "eth-lattice-keyring>@ethereumjs/tx": true, + "eth-lattice-keyring>@ethereumjs/util": true, "eth-lattice-keyring>bn.js": true, "eth-lattice-keyring>gridplus-sdk": true, - "eth-lattice-keyring>rlp": true, - "eth-lattice-keyring>secp256k1": true, - "ethereumjs-util": true + "eth-lattice-keyring>rlp": true } }, - "eth-lattice-keyring>@ethereumjs/common": { + "eth-lattice-keyring>@ethereumjs/tx": { "packages": { - "@ethereumjs/common>crc-32": true, + "@ethereumjs/common": true, "browserify>buffer": true, - "browserify>events": true, + "browserify>insert-module-globals>is-buffer": true, "ethereumjs-util": true } }, - "eth-lattice-keyring>@ethereumjs/tx": { + "eth-lattice-keyring>@ethereumjs/util": { "packages": { "browserify>buffer": true, "browserify>insert-module-globals>is-buffer": true, - "eth-lattice-keyring>@ethereumjs/tx>@ethereumjs/common": true, - "ethereumjs-util": true + "eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp": true, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography": true } }, - "eth-lattice-keyring>@ethereumjs/tx>@ethereumjs/common": { + "eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp": { + "globals": { + "TextEncoder": true + } + }, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography": { + "globals": { + "TextDecoder": true, + "crypto": true + }, "packages": { - "@ethereumjs/common>crc-32": true, - "browserify>buffer": true, - "browserify>events": true, - "ethereumjs-util": true + "@metamask/rpc-methods>@metamask/key-tree>@noble/hashes": true, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/secp256k1": true + } + }, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/secp256k1": { + "globals": { + "crypto": true + }, + "packages": { + "browserify>browser-resolve": true } }, "eth-lattice-keyring>bn.js": { @@ -5602,9 +5603,15 @@ }, "eth-lattice-keyring>gridplus-sdk": { "globals": { + "AbortController": true, + "Request": true, "__values": true, + "caches": true, + "clearTimeout": true, + "console.error": true, "console.log": true, "console.warn": true, + "fetch": true, "setTimeout": true }, "packages": { @@ -5623,7 +5630,6 @@ "eth-lattice-keyring>gridplus-sdk>eth-eip712-util-browser": true, "eth-lattice-keyring>gridplus-sdk>rlp": true, "eth-lattice-keyring>gridplus-sdk>secp256k1": true, - "eth-lattice-keyring>gridplus-sdk>superagent": true, "ethereumjs-wallet>aes-js": true, "ethereumjs-wallet>bs58check": true, "ethers>@ethersproject/keccak256>js-sha3": true, @@ -5720,33 +5726,11 @@ "3box>ethers>elliptic": true } }, - "eth-lattice-keyring>gridplus-sdk>superagent": { - "globals": { - "XMLHttpRequest": true, - "btoa": true, - "clearTimeout": true, - "console.error": true, - "console.warn": true, - "setTimeout": true - }, - "packages": { - "browserify>browser-resolve": true, - "browserify>process": true, - "eth-rpc-errors>fast-safe-stringify": true, - "nock>qs": true, - "pubnub>superagent>component-emitter": true - } - }, "eth-lattice-keyring>rlp": { "globals": { "TextEncoder": true } }, - "eth-lattice-keyring>secp256k1": { - "packages": { - "3box>ethers>elliptic": true - } - }, "eth-method-registry": { "packages": { "ethjs": true @@ -5755,7 +5739,7 @@ "eth-query": { "packages": { "eth-query>json-rpc-random-id": true, - "madge>debug": true, + "nock>debug": true, "watchify>xtend": true } }, @@ -7495,7 +7479,7 @@ "globalthis>define-properties": { "packages": { "globalthis>define-properties>has-property-descriptors": true, - "nock>deep-equal>object-keys": true + "mocha>object.assign>object-keys": true } }, "globalthis>define-properties>has-property-descriptors": { @@ -7606,19 +7590,6 @@ "Intl": true } }, - "madge>debug": { - "globals": { - "console": true, - "document": true, - "localStorage": true, - "navigator": true, - "process": true - }, - "packages": { - "browserify>process": true, - "madge>debug>ms": true - } - }, "madge>rc>deep-extend": { "packages": { "browserify>buffer": true @@ -7654,30 +7625,17 @@ "navigator": true } }, - "nock>deep-equal": { - "packages": { - "enzyme>is-regex": true, - "enzyme>object-is": true, - "nock>deep-equal>is-arguments": true, - "nock>deep-equal>is-date-object": true, - "nock>deep-equal>object-keys": true, - "string.prototype.matchall>regexp.prototype.flags": true - } - }, - "nock>deep-equal>is-arguments": { - "packages": { - "koa>is-generator-function>has-tostringtag": true, - "string.prototype.matchall>call-bind": true - } - }, - "nock>deep-equal>is-date-object": { - "packages": { - "koa>is-generator-function>has-tostringtag": true - } - }, - "nock>qs": { + "nock>debug": { + "globals": { + "console": true, + "document": true, + "localStorage": true, + "navigator": true, + "process": true + }, "packages": { - "string.prototype.matchall>side-channel": true + "browserify>process": true, + "nock>debug>ms": true } }, "node-fetch": { @@ -8293,13 +8251,6 @@ "string.prototype.matchall>call-bind": true } }, - "string.prototype.matchall>side-channel": { - "packages": { - "enzyme>object-inspect": true, - "string.prototype.matchall>call-bind": true, - "string.prototype.matchall>get-intrinsic": true - } - }, "stylelint>autoprefixer>browserslist": { "packages": { "browserify>browser-resolve": true, diff --git a/lavamoat/browserify/main/policy.json b/lavamoat/browserify/main/policy.json index fc15ef26bab5..2e1e455bc59c 100644 --- a/lavamoat/browserify/main/policy.json +++ b/lavamoat/browserify/main/policy.json @@ -288,7 +288,7 @@ "browserify>insert-module-globals>is-buffer": true, "browserify>timers-browserify": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs-mini": { @@ -388,7 +388,7 @@ "3box>ipfs>multibase": true, "browserify>assert": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>dlv": { @@ -450,7 +450,7 @@ "browserify>assert": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-bitswap>bignumber.js": { @@ -520,7 +520,7 @@ "browserify>assert": true, "browserify>browser-resolve": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-mfs>hamt-sharding": { @@ -567,7 +567,7 @@ "browserify>path-browserify": true, "browserify>timers-browserify": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>ipfs-repo>bignumber.js": { @@ -811,7 +811,7 @@ "3box>ipfs>protons": true, "base32-encode": true, "browserify>buffer": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>is-ipfs": { @@ -850,7 +850,7 @@ "browserify>insert-module-globals>is-buffer": true, "browserify>process": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -866,7 +866,7 @@ "3box>ipfs>peer-info": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p-crypto": { @@ -979,7 +979,7 @@ "browserify>events": true, "browserify>insert-module-globals>is-buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "promise-to-callback": true } }, @@ -1102,7 +1102,7 @@ "browserify>assert": true, "browserify>buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1161,7 +1161,7 @@ "3box>ipfs>stream-to-pull-stream": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1177,7 +1177,7 @@ "3box>ipfs>libp2p-webrtc-star>simple-peer>readable-stream": true, "browserify>buffer": true, "ethereumjs-wallet>randombytes": true, - "madge>debug": true, + "nock>debug": true, "pumpify>inherits": true } }, @@ -1377,7 +1377,7 @@ "3box>ipfs>multiaddr": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1399,7 +1399,7 @@ "browserify>buffer": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true, "uuid": true } @@ -1449,7 +1449,7 @@ "3box>ipfs>multiaddr-to-uri": true, "3box>ipfs>pull-mplex>interface-connection": true, "browserify>os-browserify": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p-websockets>pull-ws": { @@ -1478,7 +1478,7 @@ "packages": { "3box>ipfs>libp2p>libp2p-connection-manager>latency-monitor": true, "browserify>events": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-connection-manager>latency-monitor": { @@ -1518,7 +1518,7 @@ "3box>ipfs>pull-stream": true, "browserify>assert": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-floodsub>libp2p-pubsub": { @@ -1535,7 +1535,7 @@ "browserify>events": true, "browserify>insert-module-globals>is-buffer": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-floodsub>libp2p-pubsub>time-cache": { @@ -1555,7 +1555,7 @@ "3box>ipfs>libp2p-secio>pull-handshake": true, "3box>ipfs>pull-stream": true, "browserify>events": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>libp2p>libp2p-switch": { @@ -1578,7 +1578,7 @@ "browserify>assert": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1601,7 +1601,7 @@ "3box>ipfs>pull-stream": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1631,7 +1631,7 @@ "browserify>assert": true, "browserify>buffer": true, "gh-pages>async": true, - "madge>debug": true, + "nock>debug": true, "pump>once": true } }, @@ -1806,7 +1806,7 @@ "browserify>buffer": true, "browserify>events": true, "gh-pages>async": true, - "madge>debug": true + "nock>debug": true } }, "3box>ipfs>pull-mplex>interface-connection": { @@ -2405,36 +2405,13 @@ }, "@keystonehq/bc-ur-registry-eth": { "packages": { - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": true, "@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry": true, "@keystonehq/bc-ur-registry-eth>hdkey": true, "browserify>buffer": true, + "eth-lattice-keyring>@ethereumjs/util": true, "uuid": true } }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": { - "packages": { - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp": true, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography": true, - "browserify>buffer": true, - "browserify>insert-module-globals>is-buffer": true - } - }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>@ethereumjs/rlp": { - "globals": { - "TextEncoder": true - } - }, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util>ethereum-cryptography": { - "globals": { - "TextDecoder": true, - "crypto": true - }, - "packages": { - "@metamask/rpc-methods>@metamask/key-tree>@noble/hashes": true, - "@metamask/rpc-methods>@metamask/key-tree>@noble/secp256k1": true - } - }, "@keystonehq/bc-ur-registry-eth>@keystonehq/bc-ur-registry": { "globals": { "define": true @@ -2481,10 +2458,10 @@ "packages": { "@ethereumjs/tx": true, "@keystonehq/bc-ur-registry-eth": true, - "@keystonehq/bc-ur-registry-eth>@ethereumjs/util": true, "@keystonehq/bc-ur-registry-eth>hdkey": true, "@keystonehq/metamask-airgapped-keyring>@keystonehq/base-eth-keyring>rlp": true, "browserify>buffer": true, + "eth-lattice-keyring>@ethereumjs/util": true, "uuid": true } }, @@ -3102,7 +3079,7 @@ "packages": { "@metamask/eth-json-rpc-infura>@metamask/utils>superstruct": true, "eslint>fast-deep-equal": true, - "madge>debug": true + "nock>debug": true } }, "@metamask/eth-json-rpc-infura>eth-json-rpc-middleware": { @@ -3231,15 +3208,36 @@ }, "packages": { "@babel/runtime": true, + "@metamask/eth-token-tracker>deep-equal": true, "@metamask/eth-token-tracker>eth-block-tracker": true, "@metamask/eth-token-tracker>ethjs": true, "@metamask/eth-token-tracker>human-standard-token-abi": true, "ethjs-contract": true, "ethjs-query": true, - "nock>deep-equal": true, "safe-event-emitter": true } }, + "@metamask/eth-token-tracker>deep-equal": { + "packages": { + "@metamask/eth-token-tracker>deep-equal>is-arguments": true, + "@metamask/eth-token-tracker>deep-equal>is-date-object": true, + "enzyme>is-regex": true, + "enzyme>object-is": true, + "mocha>object.assign>object-keys": true, + "string.prototype.matchall>regexp.prototype.flags": true + } + }, + "@metamask/eth-token-tracker>deep-equal>is-arguments": { + "packages": { + "koa>is-generator-function>has-tostringtag": true, + "string.prototype.matchall>call-bind": true + } + }, + "@metamask/eth-token-tracker>deep-equal>is-date-object": { + "packages": { + "koa>is-generator-function>has-tostringtag": true + } + }, "@metamask/eth-token-tracker>eth-block-tracker": { "globals": { "clearTimeout": true, @@ -3404,14 +3402,6 @@ "crypto": true } }, - "@metamask/rpc-methods>@metamask/key-tree>@noble/secp256k1": { - "globals": { - "crypto": true - }, - "packages": { - "browserify>browser-resolve": true - } - }, "@metamask/smart-transactions-controller": { "globals": { "URLSearchParams": true, @@ -3690,7 +3680,7 @@ "browserify>buffer": true, "browserify>util": true, "gulp-dart-sass>lodash.clonedeep": true, - "madge>debug": true, + "nock>debug": true, "semver": true } }, @@ -3913,7 +3903,7 @@ "@truffle/codec>web3-utils": true, "@truffle/decoder>@truffle/source-map-utils": true, "@truffle/decoder>bn.js": true, - "madge>debug": true + "nock>debug": true } }, "@truffle/decoder>@truffle/source-map-utils": { @@ -3923,7 +3913,7 @@ "@truffle/decoder>@truffle/source-map-utils>@truffle/code-utils": true, "@truffle/decoder>@truffle/source-map-utils>json-pointer": true, "@truffle/decoder>@truffle/source-map-utils>node-interval-tree": true, - "madge>debug": true + "nock>debug": true } }, "@truffle/decoder>@truffle/source-map-utils>@truffle/code-utils": { @@ -4474,15 +4464,6 @@ "string.prototype.matchall>call-bind": true } }, - "enzyme>object-inspect": { - "globals": { - "HTMLElement": true, - "WeakRef": true - }, - "packages": { - "browserify>browser-resolve": true - } - }, "enzyme>object-is": { "packages": { "globalthis>define-properties": true, @@ -4516,7 +4497,7 @@ "packages": { "eslint>fast-deep-equal": true, "eth-block-tracker>@metamask/utils>superstruct": true, - "madge>debug": true + "nock>debug": true } }, "eth-ens-namehash": { @@ -4586,7 +4567,7 @@ "packages": { "eslint>fast-deep-equal": true, "eth-json-rpc-middleware>@metamask/utils>superstruct": true, - "madge>debug": true + "nock>debug": true } }, "eth-json-rpc-middleware>eth-sig-util": { @@ -4740,44 +4721,56 @@ "clearInterval": true, "fetch": true, "open": true, - "setInterval": true, - "txData.type": true + "setInterval": true }, "packages": { "browserify>buffer": true, "browserify>crypto-browserify": true, "browserify>events": true, - "eth-lattice-keyring>@ethereumjs/common": true, "eth-lattice-keyring>@ethereumjs/tx": true, + "eth-lattice-keyring>@ethereumjs/util": true, "eth-lattice-keyring>bn.js": true, "eth-lattice-keyring>gridplus-sdk": true, - "eth-lattice-keyring>rlp": true, - "eth-lattice-keyring>secp256k1": true, - "ethereumjs-util": true + "eth-lattice-keyring>rlp": true } }, - "eth-lattice-keyring>@ethereumjs/common": { + "eth-lattice-keyring>@ethereumjs/tx": { "packages": { - "@ethereumjs/common>crc-32": true, + "@ethereumjs/common": true, "browserify>buffer": true, - "browserify>events": true, + "browserify>insert-module-globals>is-buffer": true, "ethereumjs-util": true } }, - "eth-lattice-keyring>@ethereumjs/tx": { + "eth-lattice-keyring>@ethereumjs/util": { "packages": { "browserify>buffer": true, "browserify>insert-module-globals>is-buffer": true, - "eth-lattice-keyring>@ethereumjs/tx>@ethereumjs/common": true, - "ethereumjs-util": true + "eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp": true, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography": true + } + }, + "eth-lattice-keyring>@ethereumjs/util>@ethereumjs/rlp": { + "globals": { + "TextEncoder": true } }, - "eth-lattice-keyring>@ethereumjs/tx>@ethereumjs/common": { + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography": { + "globals": { + "TextDecoder": true, + "crypto": true + }, "packages": { - "@ethereumjs/common>crc-32": true, - "browserify>buffer": true, - "browserify>events": true, - "ethereumjs-util": true + "@metamask/rpc-methods>@metamask/key-tree>@noble/hashes": true, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/secp256k1": true + } + }, + "eth-lattice-keyring>@ethereumjs/util>ethereum-cryptography>@noble/secp256k1": { + "globals": { + "crypto": true + }, + "packages": { + "browserify>browser-resolve": true } }, "eth-lattice-keyring>bn.js": { @@ -4790,9 +4783,15 @@ }, "eth-lattice-keyring>gridplus-sdk": { "globals": { + "AbortController": true, + "Request": true, "__values": true, + "caches": true, + "clearTimeout": true, + "console.error": true, "console.log": true, "console.warn": true, + "fetch": true, "setTimeout": true }, "packages": { @@ -4811,7 +4810,6 @@ "eth-lattice-keyring>gridplus-sdk>eth-eip712-util-browser": true, "eth-lattice-keyring>gridplus-sdk>rlp": true, "eth-lattice-keyring>gridplus-sdk>secp256k1": true, - "eth-lattice-keyring>gridplus-sdk>superagent": true, "ethereumjs-wallet>aes-js": true, "ethereumjs-wallet>bs58check": true, "ethers>@ethersproject/keccak256>js-sha3": true, @@ -4908,33 +4906,11 @@ "3box>ethers>elliptic": true } }, - "eth-lattice-keyring>gridplus-sdk>superagent": { - "globals": { - "XMLHttpRequest": true, - "btoa": true, - "clearTimeout": true, - "console.error": true, - "console.warn": true, - "setTimeout": true - }, - "packages": { - "browserify>browser-resolve": true, - "browserify>process": true, - "eth-rpc-errors>fast-safe-stringify": true, - "nock>qs": true, - "pubnub>superagent>component-emitter": true - } - }, "eth-lattice-keyring>rlp": { "globals": { "TextEncoder": true } }, - "eth-lattice-keyring>secp256k1": { - "packages": { - "3box>ethers>elliptic": true - } - }, "eth-method-registry": { "packages": { "ethjs": true @@ -4943,7 +4919,7 @@ "eth-query": { "packages": { "eth-query>json-rpc-random-id": true, - "madge>debug": true, + "nock>debug": true, "watchify>xtend": true } }, @@ -6683,7 +6659,7 @@ "globalthis>define-properties": { "packages": { "globalthis>define-properties>has-property-descriptors": true, - "nock>deep-equal>object-keys": true + "mocha>object.assign>object-keys": true } }, "globalthis>define-properties>has-property-descriptors": { @@ -6774,19 +6750,6 @@ "Intl": true } }, - "madge>debug": { - "globals": { - "console": true, - "document": true, - "localStorage": true, - "navigator": true, - "process": true - }, - "packages": { - "browserify>process": true, - "madge>debug>ms": true - } - }, "madge>rc>deep-extend": { "packages": { "browserify>buffer": true @@ -6822,30 +6785,17 @@ "navigator": true } }, - "nock>deep-equal": { - "packages": { - "enzyme>is-regex": true, - "enzyme>object-is": true, - "nock>deep-equal>is-arguments": true, - "nock>deep-equal>is-date-object": true, - "nock>deep-equal>object-keys": true, - "string.prototype.matchall>regexp.prototype.flags": true - } - }, - "nock>deep-equal>is-arguments": { - "packages": { - "koa>is-generator-function>has-tostringtag": true, - "string.prototype.matchall>call-bind": true - } - }, - "nock>deep-equal>is-date-object": { - "packages": { - "koa>is-generator-function>has-tostringtag": true - } - }, - "nock>qs": { + "nock>debug": { + "globals": { + "console": true, + "document": true, + "localStorage": true, + "navigator": true, + "process": true + }, "packages": { - "string.prototype.matchall>side-channel": true + "browserify>process": true, + "nock>debug>ms": true } }, "node-fetch": { @@ -7449,13 +7399,6 @@ "string.prototype.matchall>call-bind": true } }, - "string.prototype.matchall>side-channel": { - "packages": { - "enzyme>object-inspect": true, - "string.prototype.matchall>call-bind": true, - "string.prototype.matchall>get-intrinsic": true - } - }, "stylelint>write-file-atomic>typedarray-to-buffer": { "packages": { "browserify>buffer": true, diff --git a/lavamoat/build-system/policy-override.json b/lavamoat/build-system/policy-override.json index 499e683e2df1..39640ea8d7aa 100644 --- a/lavamoat/build-system/policy-override.json +++ b/lavamoat/build-system/policy-override.json @@ -158,7 +158,8 @@ "eslint-plugin-jest>@typescript-eslint/utils": true, "eslint>debug": true, "madge>debug": true, - "typescript": true + "typescript": true, + "nock>debug": true } }, "@typescript-eslint/eslint-plugin>@typescript-eslint/type-utils>debug": { diff --git a/lavamoat/build-system/policy.json b/lavamoat/build-system/policy.json index 2cad4ca0eebb..d05fa519b195 100644 --- a/lavamoat/build-system/policy.json +++ b/lavamoat/build-system/policy.json @@ -52,7 +52,7 @@ "@babel/preset-typescript": true, "depcheck>@babel/traverse": true, "depcheck>json5": true, - "madge>debug": true, + "nock>debug": true, "nyc>convert-source-map": true } }, @@ -1046,6 +1046,11 @@ "pumpify>inherits": true } }, + "@metamask/eth-token-tracker>deep-equal>is-date-object": { + "packages": { + "koa>is-generator-function>has-tostringtag": true + } + }, "@metamask/jazzicon>color>color-convert": { "packages": { "@metamask/jazzicon>color>color-convert>color-name": true @@ -1076,6 +1081,11 @@ "util.deprecate": true } }, + "@storybook/components>qs": { + "packages": { + "string.prototype.matchall>side-channel": true + } + }, "@storybook/react>acorn-walk": { "globals": { "define": true @@ -1109,6 +1119,7 @@ "eslint-plugin-jest>@typescript-eslint/utils": true, "eslint>debug": true, "madge>debug": true, + "nock>debug": true, "typescript": true } }, @@ -1144,7 +1155,7 @@ "packages": { "@typescript-eslint/parser>@typescript-eslint/scope-manager": true, "@typescript-eslint/parser>@typescript-eslint/typescript-estree": true, - "madge>debug": true, + "nock>debug": true, "typescript": true } }, @@ -1177,7 +1188,7 @@ "@typescript-eslint/parser>@typescript-eslint/types": true, "eslint>is-glob": true, "globby": true, - "madge>debug": true, + "nock>debug": true, "semver": true, "typescript": true } @@ -1798,7 +1809,6 @@ }, "packages": { "chokidar>braces": true, - "chokidar>fsevents": true, "chokidar>glob-parent": true, "chokidar>is-binary-path": true, "chokidar>normalize-path": true, @@ -1825,12 +1835,6 @@ "chokidar>braces>fill-range>to-regex-range>is-number": true } }, - "chokidar>fsevents": { - "globals": { - "process.platform": true - }, - "native": true - }, "chokidar>glob-parent": { "builtin": { "os.platform": true, @@ -2004,7 +2008,7 @@ "depcheck>@babel/traverse>@babel/helper-hoist-variables": true, "depcheck>@babel/traverse>@babel/helper-split-export-declaration": true, "depcheck>@babel/traverse>globals": true, - "madge>debug": true + "nock>debug": true } }, "depcheck>@babel/traverse>@babel/helper-function-name": { @@ -2176,7 +2180,7 @@ "enzyme>object.assign": { "packages": { "globalthis>define-properties": true, - "nock>deep-equal>object-keys": true, + "mocha>object.assign>object-keys": true, "string.prototype.matchall>call-bind": true, "string.prototype.matchall>has-symbols": true } @@ -2243,7 +2247,7 @@ "eslint>natural-compare": true, "eslint>regexpp": true, "globby>ignore": true, - "madge>debug": true + "nock>debug": true } }, "eslint-config-prettier": { @@ -2291,7 +2295,7 @@ "brfs>resolve": true, "eslint-plugin-import>tsconfig-paths": true, "eslint>is-glob": true, - "madge>debug": true, + "nock>debug": true, "nyc>glob": true } }, @@ -2537,7 +2541,7 @@ "eslint-plugin-jsdoc>escape-string-regexp": true, "eslint-plugin-jsdoc>spdx-expression-parse": true, "eslint>esquery": true, - "madge>debug": true, + "nock>debug": true, "semver": true } }, @@ -2764,7 +2768,7 @@ "eslint>minimatch": true, "eslint>strip-json-comments": true, "globby>ignore": true, - "madge>debug": true + "nock>debug": true } }, "eslint>@humanwhocodes/config-array": { @@ -2774,7 +2778,7 @@ "packages": { "eslint>@humanwhocodes/config-array>@humanwhocodes/object-schema": true, "eslint>minimatch": true, - "madge>debug": true + "nock>debug": true } }, "eslint>ajv": { @@ -3122,7 +3126,7 @@ "globalthis>define-properties": { "packages": { "globalthis>define-properties>has-property-descriptors": true, - "nock>deep-equal>object-keys": true + "mocha>object.assign>object-keys": true } }, "globalthis>define-properties>has-property-descriptors": { @@ -3510,10 +3514,10 @@ "console.error": true }, "packages": { + "@storybook/components>qs": true, "gulp-livereload>tiny-lr>body": true, "gulp-livereload>tiny-lr>debug": true, "gulp-livereload>tiny-lr>faye-websocket": true, - "nock>qs": true, "react>object-assign": true } }, @@ -4224,7 +4228,6 @@ "gulp-watch>chokidar>anymatch": true, "gulp-watch>chokidar>async-each": true, "gulp-watch>chokidar>braces": true, - "gulp-watch>chokidar>fsevents": true, "gulp-watch>chokidar>is-binary-path": true, "gulp-watch>chokidar>normalize-path": true, "gulp-watch>chokidar>readdirp": true, @@ -4373,1319 +4376,552 @@ "webpack>micromatch>braces>fill-range>repeat-string": true } }, - "gulp-watch>chokidar>fsevents": { + "gulp-watch>chokidar>is-binary-path": { "builtin": { - "events.EventEmitter": true, - "fs.stat": true, - "path.join": true, - "util.inherits": true - }, - "globals": { - "__dirname": true, - "process.nextTick": true, - "process.platform": true, - "setImmediate": true + "path.extname": true }, "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp": true + "gulp-watch>chokidar>is-binary-path>binary-extensions": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp": { + "gulp-watch>chokidar>readdirp": { "builtin": { - "events.EventEmitter": true, - "fs.existsSync": true, - "fs.readFileSync": true, - "fs.renameSync": true, - "path.dirname": true, - "path.existsSync": true, "path.join": true, - "path.resolve": true, - "url.parse": true, - "url.resolve": true, + "path.relative": true, "util.inherits": true }, "globals": { - "__dirname": true, - "console.log": true, - "process.arch": true, - "process.cwd": true, - "process.env": true, - "process.platform": true, - "process.version.substr": true, - "process.versions": true + "setImmediate": true }, "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>detect-libc": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>semver": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>detect-libc": { - "builtin": { - "child_process.spawnSync": true, - "fs.readdirSync": true, - "os.platform": true - }, - "globals": { - "process.env": true + "fs-extra>graceful-fs": true, + "gulp-watch>chokidar>readdirp>micromatch": true, + "readable-stream": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt": { + "gulp-watch>chokidar>readdirp>micromatch": { "builtin": { - "path": true, - "stream.Stream": true, - "url": true + "path.basename": true, + "path.sep": true, + "util.inspect": true }, "globals": { - "console": true, - "process.argv": true, - "process.env.DEBUG_NOPT": true, - "process.env.NOPT_DEBUG": true, "process.platform": true }, "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt>abbrev": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt>osenv": true + "gulp-watch>chokidar>braces": true, + "gulp-watch>chokidar>readdirp>micromatch>arr-diff": true, + "gulp-watch>chokidar>readdirp>micromatch>array-unique": true, + "gulp-watch>chokidar>readdirp>micromatch>define-property": true, + "gulp-watch>chokidar>readdirp>micromatch>extend-shallow": true, + "gulp-watch>chokidar>readdirp>micromatch>extglob": true, + "gulp-watch>chokidar>readdirp>micromatch>kind-of": true, + "webpack>micromatch>fragment-cache": true, + "webpack>micromatch>nanomatch": true, + "webpack>micromatch>object.pick": true, + "webpack>micromatch>regex-not": true, + "webpack>micromatch>snapdragon": true, + "webpack>micromatch>to-regex": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt>osenv": { - "builtin": { - "child_process.exec": true, - "path": true - }, - "globals": { - "process.env.COMPUTERNAME": true, - "process.env.ComSpec": true, - "process.env.EDITOR": true, - "process.env.HOSTNAME": true, - "process.env.PATH": true, - "process.env.PROMPT": true, - "process.env.PS1": true, - "process.env.Path": true, - "process.env.SHELL": true, - "process.env.USER": true, - "process.env.USERDOMAIN": true, - "process.env.USERNAME": true, - "process.env.VISUAL": true, - "process.env.path": true, - "process.nextTick": true, - "process.platform": true - }, + "gulp-watch>chokidar>readdirp>micromatch>define-property": { "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt>osenv>os-homedir": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt>osenv>os-tmpdir": true + "gulp>gulp-cli>isobject": true, + "webpack>micromatch>define-property>is-descriptor": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt>osenv>os-homedir": { - "builtin": { - "os.homedir": true - }, - "globals": { - "process.env": true, - "process.getuid": true, - "process.platform": true + "gulp-watch>chokidar>readdirp>micromatch>extend-shallow": { + "packages": { + "gulp-watch>chokidar>readdirp>micromatch>extend-shallow>is-extendable": true, + "webpack>micromatch>extend-shallow>assign-symbols": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>nopt>osenv>os-tmpdir": { - "globals": { - "process.env.SystemRoot": true, - "process.env.TEMP": true, - "process.env.TMP": true, - "process.env.TMPDIR": true, - "process.env.windir": true, - "process.platform": true + "gulp-watch>chokidar>readdirp>micromatch>extend-shallow>is-extendable": { + "packages": { + "@babel/register>clone-deep>is-plain-object": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog": { - "builtin": { - "events.EventEmitter": true, - "util": true - }, - "globals": { - "process.nextTick": true, - "process.stderr": true - }, + "gulp-watch>chokidar>readdirp>micromatch>extglob": { "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>console-control-strings": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>set-blocking": true + "gulp-watch>chokidar>readdirp>micromatch>array-unique": true, + "gulp-watch>chokidar>readdirp>micromatch>extglob>define-property": true, + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets": true, + "gulp-watch>chokidar>readdirp>micromatch>extglob>extend-shallow": true, + "webpack>micromatch>fragment-cache": true, + "webpack>micromatch>regex-not": true, + "webpack>micromatch>snapdragon": true, + "webpack>micromatch>to-regex": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet": { - "builtin": { - "events.EventEmitter": true, - "util.inherits": true + "gulp-watch>chokidar>readdirp>micromatch>extglob>define-property": { + "packages": { + "webpack>micromatch>define-property>is-descriptor": true + } + }, + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets": { + "globals": { + "__filename": true }, "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>delegates": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream": true + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>debug": true, + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property": true, + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>extend-shallow": true, + "webpack>micromatch>extglob>expand-brackets>posix-character-classes": true, + "webpack>micromatch>regex-not": true, + "webpack>micromatch>snapdragon": true, + "webpack>micromatch>to-regex": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream": { + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>debug": { "builtin": { - "events.EventEmitter": true, - "stream": true, + "fs.SyncWriteStream": true, + "net.Socket": true, + "tty.WriteStream": true, + "tty.isatty": true, "util": true }, "globals": { - "process.browser": true, - "process.env.READABLE_STREAM": true, - "process.stderr": true, - "process.stdout": true, - "process.version.slice": true, - "setImmediate": true + "chrome": true, + "console": true, + "document": true, + "localStorage": true, + "navigator": true, + "process": true }, "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>core-util-is": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>isarray": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>process-nextick-args": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>string_decoder": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>util-deprecate": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>inherits": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>tar>safe-buffer": true + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>debug>ms": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>core-util-is": { - "globals": { - "Buffer.isBuffer": true + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property": { + "packages": { + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>process-nextick-args": { - "globals": { - "process": true + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor": { + "packages": { + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>is-accessor-descriptor": true, + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>is-data-descriptor": true, + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>kind-of": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>string_decoder": { + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>is-accessor-descriptor": { "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>tar>safe-buffer": true + "gulp-watch>anymatch>micromatch>kind-of": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>util-deprecate": { - "builtin": { - "util.deprecate": true + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>is-data-descriptor": { + "packages": { + "gulp-watch>anymatch>micromatch>kind-of": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge": { - "builtin": { - "util.format": true - }, - "globals": { - "clearInterval": true, - "process": true, - "setImmediate": true, - "setInterval": true - }, + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>extend-shallow": { "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>console-control-strings": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>aproba": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>has-unicode": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>object-assign": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>signal-exit": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>strip-ansi": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>wide-align": true + "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>extend-shallow>is-extendable": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>has-unicode": { - "builtin": { - "os.type": true - }, - "globals": { - "process.env.LANG": true, - "process.env.LC_ALL": true, - "process.env.LC_CTYPE": true + "gulp-watch>chokidar>readdirp>micromatch>extglob>extend-shallow": { + "packages": { + "gulp-watch>chokidar>readdirp>micromatch>extglob>extend-shallow>is-extendable": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>signal-exit": { + "gulp-watch>chokidar>upath": { "builtin": { - "assert.equal": true, - "events": true - }, - "globals": { - "process": true + "path": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width": { + "gulp-watch>fancy-log": { + "globals": { + "console": true, + "process.argv.indexOf": true, + "process.stderr.write": true, + "process.stdout.write": true + }, "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width>code-point-at": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width>is-fullwidth-code-point": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>strip-ansi": true + "fancy-log>ansi-gray": true, + "fancy-log>color-support": true, + "fancy-log>time-stamp": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width>is-fullwidth-code-point": { + "gulp-watch>glob-parent": { + "builtin": { + "os.platform": true, + "path": true + }, "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width>is-fullwidth-code-point>number-is-nan": true + "gulp-watch>glob-parent>is-glob": true, + "gulp-watch>glob-parent>path-dirname": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>strip-ansi": { + "gulp-watch>glob-parent>is-glob": { "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>strip-ansi>ansi-regex": true + "gulp-watch>glob-parent>is-glob>is-extglob": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>wide-align": { - "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width": true + "gulp-watch>glob-parent>path-dirname": { + "builtin": { + "path": true, + "util.inspect": true + }, + "globals": { + "process.platform": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>npmlog>set-blocking": { + "gulp-watch>path-is-absolute": { "globals": { - "process.stderr": true, - "process.stdout": true + "process.platform": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf": { + "gulp-watch>vinyl-file": { "builtin": { - "assert": true, - "fs": true, - "path.join": true + "path.resolve": true }, "globals": { - "process.platform": true, - "setTimeout": true + "process.cwd": true }, "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob": true + "del>globby>pinkie-promise": true, + "fs-extra>graceful-fs": true, + "gulp-watch>vinyl-file>pify": true, + "gulp-watch>vinyl-file>strip-bom": true, + "gulp-watch>vinyl-file>strip-bom-stream": true, + "gulp-watch>vinyl-file>vinyl": true } }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob": { - "builtin": { - "assert": true, - "events.EventEmitter": true, - "fs.lstat": true, - "fs.lstatSync": true, - "fs.readdir": true, - "fs.readdirSync": true, - "fs.stat": true, - "fs.statSync": true, - "path.join": true, - "path.resolve": true, - "util": true - }, - "globals": { - "console.error": true, - "process.cwd": true, - "process.nextTick": true, - "process.platform": true - }, - "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>fs.realpath": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>inflight": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>inherits": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>once": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>path-is-absolute": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>fs.realpath": { - "builtin": { - "fs.lstat": true, - "fs.lstatSync": true, - "fs.readlink": true, - "fs.readlinkSync": true, - "fs.realpath": true, - "fs.realpathSync": true, - "fs.stat": true, - "fs.statSync": true, - "path.normalize": true, - "path.resolve": true - }, - "globals": { - "console.error": true, - "console.trace": true, - "process.env.NODE_DEBUG": true, - "process.nextTick": true, - "process.noDeprecation": true, - "process.platform": true, - "process.throwDeprecation": true, - "process.traceDeprecation": true, - "process.version": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>inflight": { - "globals": { - "process.nextTick": true - }, - "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>once": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>once>wrappy": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>inherits": { - "builtin": { - "util.inherits": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch": { - "builtin": { - "path": true - }, - "globals": { - "console.error": true - }, - "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch>brace-expansion": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch>brace-expansion": { - "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch>brace-expansion>balanced-match": true, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch>brace-expansion>concat-map": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>once": { - "packages": { - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>once>wrappy": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>rimraf>glob>path-is-absolute": { - "globals": { - "process.platform": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>semver": { - "globals": { - "console": true, - "process": true - } - }, - "gulp-watch>chokidar>fsevents>node-pre-gyp>tar>safe-buffer": { - "builtin": { - "buffer": true - } - }, - "gulp-watch>chokidar>is-binary-path": { - "builtin": { - "path.extname": true - }, - "packages": { - "gulp-watch>chokidar>is-binary-path>binary-extensions": true - } - }, - "gulp-watch>chokidar>readdirp": { - "builtin": { - "path.join": true, - "path.relative": true, - "util.inherits": true - }, - "globals": { - "setImmediate": true - }, - "packages": { - "fs-extra>graceful-fs": true, - "gulp-watch>chokidar>readdirp>micromatch": true, - "readable-stream": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch": { - "builtin": { - "path.basename": true, - "path.sep": true, - "util.inspect": true - }, - "globals": { - "process.platform": true - }, - "packages": { - "gulp-watch>chokidar>braces": true, - "gulp-watch>chokidar>readdirp>micromatch>arr-diff": true, - "gulp-watch>chokidar>readdirp>micromatch>array-unique": true, - "gulp-watch>chokidar>readdirp>micromatch>define-property": true, - "gulp-watch>chokidar>readdirp>micromatch>extend-shallow": true, - "gulp-watch>chokidar>readdirp>micromatch>extglob": true, - "gulp-watch>chokidar>readdirp>micromatch>kind-of": true, - "webpack>micromatch>fragment-cache": true, - "webpack>micromatch>nanomatch": true, - "webpack>micromatch>object.pick": true, - "webpack>micromatch>regex-not": true, - "webpack>micromatch>snapdragon": true, - "webpack>micromatch>to-regex": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>define-property": { - "packages": { - "gulp>gulp-cli>isobject": true, - "webpack>micromatch>define-property>is-descriptor": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extend-shallow": { - "packages": { - "gulp-watch>chokidar>readdirp>micromatch>extend-shallow>is-extendable": true, - "webpack>micromatch>extend-shallow>assign-symbols": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extend-shallow>is-extendable": { - "packages": { - "@babel/register>clone-deep>is-plain-object": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob": { - "packages": { - "gulp-watch>chokidar>readdirp>micromatch>array-unique": true, - "gulp-watch>chokidar>readdirp>micromatch>extglob>define-property": true, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets": true, - "gulp-watch>chokidar>readdirp>micromatch>extglob>extend-shallow": true, - "webpack>micromatch>fragment-cache": true, - "webpack>micromatch>regex-not": true, - "webpack>micromatch>snapdragon": true, - "webpack>micromatch>to-regex": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>define-property": { - "packages": { - "webpack>micromatch>define-property>is-descriptor": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets": { - "globals": { - "__filename": true - }, - "packages": { - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>debug": true, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property": true, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>extend-shallow": true, - "webpack>micromatch>extglob>expand-brackets>posix-character-classes": true, - "webpack>micromatch>regex-not": true, - "webpack>micromatch>snapdragon": true, - "webpack>micromatch>to-regex": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>debug": { - "builtin": { - "fs.SyncWriteStream": true, - "net.Socket": true, - "tty.WriteStream": true, - "tty.isatty": true, - "util": true - }, - "globals": { - "chrome": true, - "console": true, - "document": true, - "localStorage": true, - "navigator": true, - "process": true - }, - "packages": { - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>debug>ms": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property": { - "packages": { - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor": { - "packages": { - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>is-accessor-descriptor": true, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>is-data-descriptor": true, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>kind-of": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>is-accessor-descriptor": { - "packages": { - "gulp-watch>anymatch>micromatch>kind-of": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>define-property>is-descriptor>is-data-descriptor": { - "packages": { - "gulp-watch>anymatch>micromatch>kind-of": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>extend-shallow": { - "packages": { - "gulp-watch>chokidar>readdirp>micromatch>extglob>expand-brackets>extend-shallow>is-extendable": true - } - }, - "gulp-watch>chokidar>readdirp>micromatch>extglob>extend-shallow": { - "packages": { - "gulp-watch>chokidar>readdirp>micromatch>extglob>extend-shallow>is-extendable": true - } - }, - "gulp-watch>chokidar>upath": { - "builtin": { - "path": true - } - }, - "gulp-watch>fancy-log": { - "globals": { - "console": true, - "process.argv.indexOf": true, - "process.stderr.write": true, - "process.stdout.write": true - }, - "packages": { - "fancy-log>ansi-gray": true, - "fancy-log>color-support": true, - "fancy-log>time-stamp": true - } - }, - "gulp-watch>glob-parent": { - "builtin": { - "os.platform": true, - "path": true - }, - "packages": { - "gulp-watch>glob-parent>is-glob": true, - "gulp-watch>glob-parent>path-dirname": true - } - }, - "gulp-watch>glob-parent>is-glob": { - "packages": { - "gulp-watch>glob-parent>is-glob>is-extglob": true - } - }, - "gulp-watch>glob-parent>path-dirname": { - "builtin": { - "path": true, - "util.inspect": true - }, - "globals": { - "process.platform": true - } - }, - "gulp-watch>path-is-absolute": { - "globals": { - "process.platform": true - } - }, - "gulp-watch>vinyl-file": { - "builtin": { - "path.resolve": true - }, - "globals": { - "process.cwd": true - }, - "packages": { - "del>globby>pinkie-promise": true, - "fs-extra>graceful-fs": true, - "gulp-watch>vinyl-file>pify": true, - "gulp-watch>vinyl-file>strip-bom": true, - "gulp-watch>vinyl-file>strip-bom-stream": true, - "gulp-watch>vinyl-file>vinyl": true - } - }, - "gulp-watch>vinyl-file>strip-bom": { - "globals": { - "Buffer.isBuffer": true - }, - "packages": { - "gulp>vinyl-fs>remove-bom-buffer>is-utf8": true - } - }, - "gulp-watch>vinyl-file>strip-bom-stream": { - "packages": { - "gulp-watch>vinyl-file>strip-bom": true, - "gulp-watch>vinyl-file>strip-bom-stream>first-chunk-stream": true - } - }, - "gulp-watch>vinyl-file>strip-bom-stream>first-chunk-stream": { - "builtin": { - "util.inherits": true - }, - "globals": { - "Buffer.concat": true, - "setImmediate": true - }, - "packages": { - "readable-stream": true - } - }, - "gulp-watch>vinyl-file>vinyl": { - "builtin": { - "buffer.Buffer": true, - "path.basename": true, - "path.dirname": true, - "path.extname": true, - "path.join": true, - "path.relative": true, - "stream.PassThrough": true, - "stream.Stream": true - }, - "globals": { - "process.cwd": true - }, - "packages": { - "gulp-watch>vinyl-file>vinyl>clone": true, - "gulp-watch>vinyl-file>vinyl>clone-stats": true, - "gulp-watch>vinyl-file>vinyl>replace-ext": true - } - }, - "gulp-watch>vinyl-file>vinyl>clone": { - "globals": { - "Buffer": true - } - }, - "gulp-watch>vinyl-file>vinyl>clone-stats": { - "builtin": { - "fs.Stats": true - } - }, - "gulp-watch>vinyl-file>vinyl>replace-ext": { - "builtin": { - "path.basename": true, - "path.dirname": true, - "path.extname": true, - "path.join": true - } - }, - "gulp-zip": { - "builtin": { - "buffer.constants.MAX_LENGTH": true, - "path.join": true - }, - "packages": { - "gulp-zip>get-stream": true, - "gulp-zip>plugin-error": true, - "gulp-zip>through2": true, - "gulp-zip>yazl": true, - "vinyl": true - } - }, - "gulp-zip>get-stream": { - "builtin": { - "buffer.constants.MAX_LENGTH": true, - "stream.PassThrough": true - }, - "globals": { - "Buffer.concat": true - }, - "packages": { - "pump": true - } - }, - "gulp-zip>plugin-error": { - "builtin": { - "util.inherits": true - }, - "packages": { - "gulp-watch>ansi-colors": true, - "gulp-zip>plugin-error>arr-union": true, - "gulp-zip>plugin-error>extend-shallow": true, - "webpack>micromatch>arr-diff": true - } - }, - "gulp-zip>plugin-error>extend-shallow": { - "packages": { - "gulp-zip>plugin-error>extend-shallow>is-extendable": true, - "webpack>micromatch>extend-shallow>assign-symbols": true - } - }, - "gulp-zip>plugin-error>extend-shallow>is-extendable": { - "packages": { - "@babel/register>clone-deep>is-plain-object": true - } - }, - "gulp-zip>through2": { - "builtin": { - "util.inherits": true - }, - "globals": { - "process.nextTick": true - }, - "packages": { - "gulp-zip>through2>readable-stream": true - } - }, - "gulp-zip>through2>readable-stream": { - "builtin": { - "buffer.Buffer": true, - "events.EventEmitter": true, - "stream": true, - "util": true - }, - "globals": { - "process.env.READABLE_STREAM": true, - "process.nextTick": true, - "process.stderr": true, - "process.stdout": true - }, - "packages": { - "@storybook/api>util-deprecate": true, - "browserify>string_decoder": true, - "pumpify>inherits": true - } - }, - "gulp-zip>yazl": { - "builtin": { - "events.EventEmitter": true, - "fs.createReadStream": true, - "fs.stat": true, - "stream.PassThrough": true, - "stream.Transform": true, - "util.inherits": true, - "zlib.DeflateRaw": true, - "zlib.deflateRaw": true - }, - "globals": { - "Buffer": true, - "setImmediate": true, - "utf8FileName.length": true - }, - "packages": { - "gulp-zip>yazl>buffer-crc32": true - } - }, - "gulp-zip>yazl>buffer-crc32": { - "builtin": { - "buffer.Buffer": true - } - }, - "gulp>glob-watcher": { - "packages": { - "gulp>glob-watcher>anymatch": true, - "gulp>glob-watcher>async-done": true, - "gulp>glob-watcher>chokidar": true, - "gulp>glob-watcher>is-negated-glob": true, - "gulp>glob-watcher>just-debounce": true, - "gulp>undertaker>object.defaults": true - } - }, - "gulp>glob-watcher>anymatch": { - "builtin": { - "path.sep": true - }, - "packages": { - "gulp>glob-watcher>anymatch>micromatch": true, - "gulp>glob-watcher>anymatch>normalize-path": true - } - }, - "gulp>glob-watcher>anymatch>micromatch": { - "builtin": { - "path.basename": true, - "path.sep": true, - "util.inspect": true - }, + "gulp-watch>vinyl-file>strip-bom": { "globals": { - "process.platform": true + "Buffer.isBuffer": true }, "packages": { - "3box>ipfs>kind-of": true, - "gulp>glob-watcher>anymatch>micromatch>define-property": true, - "gulp>glob-watcher>anymatch>micromatch>extend-shallow": true, - "gulp>glob-watcher>chokidar>braces": true, - "webpack>micromatch>arr-diff": true, - "webpack>micromatch>array-unique": true, - "webpack>micromatch>extglob": true, - "webpack>micromatch>fragment-cache": true, - "webpack>micromatch>nanomatch": true, - "webpack>micromatch>object.pick": true, - "webpack>micromatch>regex-not": true, - "webpack>micromatch>snapdragon": true, - "webpack>micromatch>to-regex": true - } - }, - "gulp>glob-watcher>anymatch>micromatch>define-property": { - "packages": { - "gulp>gulp-cli>isobject": true, - "webpack>micromatch>define-property>is-descriptor": true - } - }, - "gulp>glob-watcher>anymatch>micromatch>extend-shallow": { - "packages": { - "gulp>glob-watcher>anymatch>micromatch>extend-shallow>is-extendable": true, - "webpack>micromatch>extend-shallow>assign-symbols": true - } - }, - "gulp>glob-watcher>anymatch>micromatch>extend-shallow>is-extendable": { - "packages": { - "@babel/register>clone-deep>is-plain-object": true - } - }, - "gulp>glob-watcher>anymatch>normalize-path": { - "packages": { - "vinyl>remove-trailing-separator": true + "gulp>vinyl-fs>remove-bom-buffer>is-utf8": true } }, - "gulp>glob-watcher>async-done": { - "builtin": { - "domain.create": true - }, - "globals": { - "process.nextTick": true - }, + "gulp-watch>vinyl-file>strip-bom-stream": { "packages": { - "end-of-stream": true, - "gulp>glob-watcher>async-done>process-nextick-args": true, - "gulp>glob-watcher>async-done>stream-exhaust": true, - "pump>once": true - } - }, - "gulp>glob-watcher>async-done>process-nextick-args": { - "globals": { - "process": true + "gulp-watch>vinyl-file>strip-bom": true, + "gulp-watch>vinyl-file>strip-bom-stream>first-chunk-stream": true } }, - "gulp>glob-watcher>async-done>stream-exhaust": { + "gulp-watch>vinyl-file>strip-bom-stream>first-chunk-stream": { "builtin": { - "stream.Writable": true, "util.inherits": true }, "globals": { + "Buffer.concat": true, "setImmediate": true + }, + "packages": { + "readable-stream": true } }, - "gulp>glob-watcher>chokidar": { + "gulp-watch>vinyl-file>vinyl": { "builtin": { - "events.EventEmitter": true, - "fs": true, + "buffer.Buffer": true, "path.basename": true, "path.dirname": true, "path.extname": true, "path.join": true, "path.relative": true, - "path.resolve": true, - "path.sep": true + "stream.PassThrough": true, + "stream.Stream": true }, "globals": { - "clearTimeout": true, - "console.error": true, - "process.env.CHOKIDAR_INTERVAL": true, - "process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR": true, - "process.env.CHOKIDAR_USEPOLLING": true, - "process.nextTick": true, - "process.platform": true, - "setTimeout": true + "process.cwd": true }, "packages": { - "eslint>is-glob": true, - "gulp-watch>chokidar>async-each": true, - "gulp-watch>glob-parent": true, - "gulp-watch>path-is-absolute": true, - "gulp>glob-watcher>anymatch": true, - "gulp>glob-watcher>chokidar>braces": true, - "gulp>glob-watcher>chokidar>fsevents": true, - "gulp>glob-watcher>chokidar>is-binary-path": true, - "gulp>glob-watcher>chokidar>normalize-path": true, - "gulp>glob-watcher>chokidar>readdirp": true, - "gulp>glob-watcher>chokidar>upath": true, - "pumpify>inherits": true + "gulp-watch>vinyl-file>vinyl>clone": true, + "gulp-watch>vinyl-file>vinyl>clone-stats": true, + "gulp-watch>vinyl-file>vinyl>replace-ext": true } }, - "gulp>glob-watcher>chokidar>braces": { - "packages": { - "gulp>glob-watcher>chokidar>braces>fill-range": true, - "gulp>gulp-cli>isobject": true, - "gulp>undertaker>arr-flatten": true, - "webpack>micromatch>array-unique": true, - "webpack>micromatch>braces>repeat-element": true, - "webpack>micromatch>braces>snapdragon-node": true, - "webpack>micromatch>braces>split-string": true, - "webpack>micromatch>extglob>extend-shallow": true, - "webpack>micromatch>snapdragon": true, - "webpack>micromatch>to-regex": true + "gulp-watch>vinyl-file>vinyl>clone": { + "globals": { + "Buffer": true } }, - "gulp>glob-watcher>chokidar>braces>fill-range": { + "gulp-watch>vinyl-file>vinyl>clone-stats": { "builtin": { - "util.inspect": true - }, - "packages": { - "gulp>glob-watcher>chokidar>braces>fill-range>is-number": true, - "gulp>glob-watcher>chokidar>braces>fill-range>to-regex-range": true, - "webpack>micromatch>braces>fill-range>repeat-string": true, - "webpack>micromatch>extglob>extend-shallow": true - } - }, - "gulp>glob-watcher>chokidar>braces>fill-range>is-number": { - "packages": { - "gulp>glob-watcher>chokidar>braces>fill-range>is-number>kind-of": true + "fs.Stats": true } }, - "gulp>glob-watcher>chokidar>braces>fill-range>is-number>kind-of": { - "packages": { - "browserify>insert-module-globals>is-buffer": true + "gulp-watch>vinyl-file>vinyl>replace-ext": { + "builtin": { + "path.basename": true, + "path.dirname": true, + "path.extname": true, + "path.join": true } }, - "gulp>glob-watcher>chokidar>braces>fill-range>to-regex-range": { + "gulp-zip": { + "builtin": { + "buffer.constants.MAX_LENGTH": true, + "path.join": true + }, "packages": { - "gulp>glob-watcher>chokidar>braces>fill-range>is-number": true, - "webpack>micromatch>braces>fill-range>repeat-string": true + "gulp-zip>get-stream": true, + "gulp-zip>plugin-error": true, + "gulp-zip>through2": true, + "gulp-zip>yazl": true, + "vinyl": true } }, - "gulp>glob-watcher>chokidar>fsevents": { + "gulp-zip>get-stream": { "builtin": { - "events.EventEmitter": true, - "fs.stat": true, - "path.join": true, - "util.inherits": true + "buffer.constants.MAX_LENGTH": true, + "stream.PassThrough": true }, "globals": { - "__dirname": true, - "process.nextTick": true, - "process.platform": true, - "setImmediate": true + "Buffer.concat": true }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp": true + "pump": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp": { + "gulp-zip>plugin-error": { "builtin": { - "events.EventEmitter": true, - "fs.existsSync": true, - "fs.readFileSync": true, - "fs.renameSync": true, - "path.dirname": true, - "path.existsSync": true, - "path.join": true, - "path.resolve": true, - "url.parse": true, - "url.resolve": true, "util.inherits": true }, - "globals": { - "__dirname": true, - "console.log": true, - "process.arch": true, - "process.cwd": true, - "process.env": true, - "process.platform": true, - "process.version.substr": true, - "process.versions": true - }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>detect-libc": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>semver": true + "gulp-watch>ansi-colors": true, + "gulp-zip>plugin-error>arr-union": true, + "gulp-zip>plugin-error>extend-shallow": true, + "webpack>micromatch>arr-diff": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>detect-libc": { - "builtin": { - "child_process.spawnSync": true, - "fs.readdirSync": true, - "os.platform": true - }, - "globals": { - "process.env": true + "gulp-zip>plugin-error>extend-shallow": { + "packages": { + "gulp-zip>plugin-error>extend-shallow>is-extendable": true, + "webpack>micromatch>extend-shallow>assign-symbols": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt": { - "builtin": { - "path": true, - "stream.Stream": true, - "url": true - }, - "globals": { - "console": true, - "process.argv": true, - "process.env.DEBUG_NOPT": true, - "process.env.NOPT_DEBUG": true, - "process.platform": true - }, + "gulp-zip>plugin-error>extend-shallow>is-extendable": { "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt>abbrev": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt>osenv": true + "@babel/register>clone-deep>is-plain-object": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt>osenv": { + "gulp-zip>through2": { "builtin": { - "child_process.exec": true, - "path": true + "util.inherits": true }, "globals": { - "process.env.COMPUTERNAME": true, - "process.env.ComSpec": true, - "process.env.EDITOR": true, - "process.env.HOSTNAME": true, - "process.env.PATH": true, - "process.env.PROMPT": true, - "process.env.PS1": true, - "process.env.Path": true, - "process.env.SHELL": true, - "process.env.USER": true, - "process.env.USERDOMAIN": true, - "process.env.USERNAME": true, - "process.env.VISUAL": true, - "process.env.path": true, - "process.nextTick": true, - "process.platform": true + "process.nextTick": true }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt>osenv>os-homedir": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt>osenv>os-tmpdir": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt>osenv>os-homedir": { - "builtin": { - "os.homedir": true - }, - "globals": { - "process.env": true, - "process.getuid": true, - "process.platform": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>nopt>osenv>os-tmpdir": { - "globals": { - "process.env.SystemRoot": true, - "process.env.TEMP": true, - "process.env.TMP": true, - "process.env.TMPDIR": true, - "process.env.windir": true, - "process.platform": true + "gulp-zip>through2>readable-stream": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog": { + "gulp-zip>through2>readable-stream": { "builtin": { + "buffer.Buffer": true, "events.EventEmitter": true, + "stream": true, "util": true }, "globals": { + "process.env.READABLE_STREAM": true, "process.nextTick": true, - "process.stderr": true - }, - "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>console-control-strings": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>set-blocking": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet": { - "builtin": { - "events.EventEmitter": true, - "util.inherits": true + "process.stderr": true, + "process.stdout": true }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>delegates": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream": true + "@storybook/api>util-deprecate": true, + "browserify>string_decoder": true, + "pumpify>inherits": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream": { + "gulp-zip>yazl": { "builtin": { "events.EventEmitter": true, - "stream": true, - "util": true + "fs.createReadStream": true, + "fs.stat": true, + "stream.PassThrough": true, + "stream.Transform": true, + "util.inherits": true, + "zlib.DeflateRaw": true, + "zlib.deflateRaw": true }, "globals": { - "process.browser": true, - "process.env.READABLE_STREAM": true, - "process.stderr": true, - "process.stdout": true, - "process.version.slice": true, - "setImmediate": true + "Buffer": true, + "setImmediate": true, + "utf8FileName.length": true }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>core-util-is": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>isarray": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>process-nextick-args": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>string_decoder": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>util-deprecate": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>inherits": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>tar>safe-buffer": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>core-util-is": { - "globals": { - "Buffer.isBuffer": true + "gulp-zip>yazl>buffer-crc32": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>process-nextick-args": { - "globals": { - "process": true + "gulp-zip>yazl>buffer-crc32": { + "builtin": { + "buffer.Buffer": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>string_decoder": { + "gulp>glob-watcher": { "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>tar>safe-buffer": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>are-we-there-yet>readable-stream>util-deprecate": { - "builtin": { - "util.deprecate": true + "gulp>glob-watcher>anymatch": true, + "gulp>glob-watcher>async-done": true, + "gulp>glob-watcher>chokidar": true, + "gulp>glob-watcher>is-negated-glob": true, + "gulp>glob-watcher>just-debounce": true, + "gulp>undertaker>object.defaults": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge": { + "gulp>glob-watcher>anymatch": { "builtin": { - "util.format": true - }, - "globals": { - "clearInterval": true, - "process": true, - "setImmediate": true, - "setInterval": true + "path.sep": true }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>console-control-strings": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>aproba": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>has-unicode": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>object-assign": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>signal-exit": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>strip-ansi": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>wide-align": true + "gulp>glob-watcher>anymatch>micromatch": true, + "gulp>glob-watcher>anymatch>normalize-path": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>has-unicode": { + "gulp>glob-watcher>anymatch>micromatch": { "builtin": { - "os.type": true + "path.basename": true, + "path.sep": true, + "util.inspect": true }, "globals": { - "process.env.LANG": true, - "process.env.LC_ALL": true, - "process.env.LC_CTYPE": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>signal-exit": { - "builtin": { - "assert.equal": true, - "events": true + "process.platform": true }, - "globals": { - "process": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width": { "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width>code-point-at": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width>is-fullwidth-code-point": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>strip-ansi": true + "3box>ipfs>kind-of": true, + "gulp>glob-watcher>anymatch>micromatch>define-property": true, + "gulp>glob-watcher>anymatch>micromatch>extend-shallow": true, + "gulp>glob-watcher>chokidar>braces": true, + "webpack>micromatch>arr-diff": true, + "webpack>micromatch>array-unique": true, + "webpack>micromatch>extglob": true, + "webpack>micromatch>fragment-cache": true, + "webpack>micromatch>nanomatch": true, + "webpack>micromatch>object.pick": true, + "webpack>micromatch>regex-not": true, + "webpack>micromatch>snapdragon": true, + "webpack>micromatch>to-regex": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width>is-fullwidth-code-point": { + "gulp>glob-watcher>anymatch>micromatch>define-property": { "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width>is-fullwidth-code-point>number-is-nan": true + "gulp>gulp-cli>isobject": true, + "webpack>micromatch>define-property>is-descriptor": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>strip-ansi": { + "gulp>glob-watcher>anymatch>micromatch>extend-shallow": { "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>strip-ansi>ansi-regex": true + "gulp>glob-watcher>anymatch>micromatch>extend-shallow>is-extendable": true, + "webpack>micromatch>extend-shallow>assign-symbols": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>wide-align": { + "gulp>glob-watcher>anymatch>micromatch>extend-shallow>is-extendable": { "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>gauge>string-width": true + "@babel/register>clone-deep>is-plain-object": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>npmlog>set-blocking": { - "globals": { - "process.stderr": true, - "process.stdout": true + "gulp>glob-watcher>anymatch>normalize-path": { + "packages": { + "vinyl>remove-trailing-separator": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf": { + "gulp>glob-watcher>async-done": { "builtin": { - "assert": true, - "fs": true, - "path.join": true + "domain.create": true }, "globals": { - "process.platform": true, - "setTimeout": true + "process.nextTick": true }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob": true + "end-of-stream": true, + "gulp>glob-watcher>async-done>process-nextick-args": true, + "gulp>glob-watcher>async-done>stream-exhaust": true, + "pump>once": true + } + }, + "gulp>glob-watcher>async-done>process-nextick-args": { + "globals": { + "process": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob": { + "gulp>glob-watcher>async-done>stream-exhaust": { "builtin": { - "assert": true, - "events.EventEmitter": true, - "fs.lstat": true, - "fs.lstatSync": true, - "fs.readdir": true, - "fs.readdirSync": true, - "fs.stat": true, - "fs.statSync": true, - "path.join": true, - "path.resolve": true, - "util": true + "stream.Writable": true, + "util.inherits": true }, "globals": { - "console.error": true, - "process.cwd": true, - "process.nextTick": true, - "process.platform": true - }, - "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>fs.realpath": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>inflight": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>inherits": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>once": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>path-is-absolute": true + "setImmediate": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>fs.realpath": { + "gulp>glob-watcher>chokidar": { "builtin": { - "fs.lstat": true, - "fs.lstatSync": true, - "fs.readlink": true, - "fs.readlinkSync": true, - "fs.realpath": true, - "fs.realpathSync": true, - "fs.stat": true, - "fs.statSync": true, - "path.normalize": true, - "path.resolve": true + "events.EventEmitter": true, + "fs": true, + "path.basename": true, + "path.dirname": true, + "path.extname": true, + "path.join": true, + "path.relative": true, + "path.resolve": true, + "path.sep": true }, "globals": { + "clearTimeout": true, "console.error": true, - "console.trace": true, - "process.env.NODE_DEBUG": true, + "process.env.CHOKIDAR_INTERVAL": true, + "process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR": true, + "process.env.CHOKIDAR_USEPOLLING": true, "process.nextTick": true, - "process.noDeprecation": true, "process.platform": true, - "process.throwDeprecation": true, - "process.traceDeprecation": true, - "process.version": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>inflight": { - "globals": { - "process.nextTick": true + "setTimeout": true }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>once": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>once>wrappy": true + "eslint>is-glob": true, + "gulp-watch>chokidar>async-each": true, + "gulp-watch>glob-parent": true, + "gulp-watch>path-is-absolute": true, + "gulp>glob-watcher>anymatch": true, + "gulp>glob-watcher>chokidar>braces": true, + "gulp>glob-watcher>chokidar>is-binary-path": true, + "gulp>glob-watcher>chokidar>normalize-path": true, + "gulp>glob-watcher>chokidar>readdirp": true, + "gulp>glob-watcher>chokidar>upath": true, + "pumpify>inherits": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>inherits": { - "builtin": { - "util.inherits": true + "gulp>glob-watcher>chokidar>braces": { + "packages": { + "gulp>glob-watcher>chokidar>braces>fill-range": true, + "gulp>gulp-cli>isobject": true, + "gulp>undertaker>arr-flatten": true, + "webpack>micromatch>array-unique": true, + "webpack>micromatch>braces>repeat-element": true, + "webpack>micromatch>braces>snapdragon-node": true, + "webpack>micromatch>braces>split-string": true, + "webpack>micromatch>extglob>extend-shallow": true, + "webpack>micromatch>snapdragon": true, + "webpack>micromatch>to-regex": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch": { + "gulp>glob-watcher>chokidar>braces>fill-range": { "builtin": { - "path": true - }, - "globals": { - "console.error": true + "util.inspect": true }, "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch>brace-expansion": true + "gulp>glob-watcher>chokidar>braces>fill-range>is-number": true, + "gulp>glob-watcher>chokidar>braces>fill-range>to-regex-range": true, + "webpack>micromatch>braces>fill-range>repeat-string": true, + "webpack>micromatch>extglob>extend-shallow": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch>brace-expansion": { + "gulp>glob-watcher>chokidar>braces>fill-range>is-number": { "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch>brace-expansion>balanced-match": true, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>minimatch>brace-expansion>concat-map": true + "gulp>glob-watcher>chokidar>braces>fill-range>is-number>kind-of": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>once": { + "gulp>glob-watcher>chokidar>braces>fill-range>is-number>kind-of": { "packages": { - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>once>wrappy": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>rimraf>glob>path-is-absolute": { - "globals": { - "process.platform": true - } - }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>semver": { - "globals": { - "console": true, - "process": true + "browserify>insert-module-globals>is-buffer": true } }, - "gulp>glob-watcher>chokidar>fsevents>node-pre-gyp>tar>safe-buffer": { - "builtin": { - "buffer": true + "gulp>glob-watcher>chokidar>braces>fill-range>to-regex-range": { + "packages": { + "gulp>glob-watcher>chokidar>braces>fill-range>is-number": true, + "webpack>micromatch>braces>fill-range>repeat-string": true } }, "gulp>glob-watcher>chokidar>is-binary-path": { @@ -6452,25 +5688,6 @@ "loose-envify>js-tokens": true } }, - "madge>debug": { - "builtin": { - "tty.isatty": true, - "util.deprecate": true, - "util.format": true, - "util.inspect": true - }, - "globals": { - "console": true, - "document": true, - "localStorage": true, - "navigator": true, - "process": true - }, - "packages": { - "madge>debug>ms": true, - "sinon>supports-color": true - } - }, "madge>detective-scss>gonzales-pe": { "globals": { "console.error": true, @@ -6498,6 +5715,13 @@ "stylelint>balanced-match": true } }, + "mocha>mkdirp": { + "builtin": { + "fs": true, + "path.dirname": true, + "path.resolve": true + } + }, "mocha>supports-color>has-flag": { "globals": { "process.argv": true @@ -6530,21 +5754,23 @@ "process.platform": true } }, - "nock>deep-equal>is-date-object": { - "packages": { - "koa>is-generator-function>has-tostringtag": true - } - }, - "nock>mkdirp": { + "nock>debug": { "builtin": { - "fs": true, - "path.dirname": true, - "path.resolve": true - } - }, - "nock>qs": { + "tty.isatty": true, + "util.deprecate": true, + "util.format": true, + "util.inspect": true + }, + "globals": { + "console": true, + "document": true, + "localStorage": true, + "navigator": true, + "process": true + }, "packages": { - "string.prototype.matchall>side-channel": true + "nock>debug>ms": true, + "sinon>supports-color": true } }, "node-sass": { @@ -6960,9 +6186,9 @@ }, "string.prototype.matchall>es-abstract>es-to-primitive": { "packages": { + "@metamask/eth-token-tracker>deep-equal>is-date-object": true, "@storybook/api>telejson>is-symbol": true, - "enzyme>is-callable": true, - "nock>deep-equal>is-date-object": true + "enzyme>is-callable": true } }, "string.prototype.matchall>get-intrinsic": { @@ -7029,7 +6255,7 @@ "globby>ignore": true, "globby>slash": true, "lodash": true, - "madge>debug": true, + "nock>debug": true, "nyc>resolve-from": true, "stylelint>@stylelint/postcss-css-in-js": true, "stylelint>@stylelint/postcss-markdown": true, @@ -7343,7 +6569,7 @@ "path.dirname": true }, "packages": { - "nock>mkdirp": true + "mocha>mkdirp": true } }, "stylelint>global-modules": { diff --git a/package.json b/package.json index 3d9fbb4c841e..78505dd26385 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "metamask-crx", - "version": "10.19.0", + "version": "10.20.0", "private": true, "repository": { "type": "git", @@ -99,6 +99,7 @@ "3box/**/libp2p-crypto/node-forge": "^1.3.0", "3box/**/libp2p-keychain/node-forge": "^1.3.0", "3box/ipfs/libp2p-webrtc-star/socket.io/engine.io": "^4.0.0", + "3box/**/@hapi/hoek": "^8.5.1", "analytics-node/axios": "^0.21.2", "ganache-core/lodash": "^4.17.21", "netmask": "^2.0.1", @@ -167,7 +168,7 @@ "eth-json-rpc-filters": "^4.2.1", "eth-json-rpc-middleware": "^9.0.0", "eth-keyring-controller": "^7.0.2", - "eth-lattice-keyring": "^0.12.0", + "eth-lattice-keyring": "^0.12.3", "eth-method-registry": "^2.0.0", "eth-query": "^2.1.2", "eth-rpc-errors": "^4.0.2", @@ -363,7 +364,7 @@ "madge": "^5.0.1", "mocha": "^7.2.0", "mockttp": "^2.6.0", - "nock": "^9.0.14", + "nock": "^13.2.9", "node-fetch": "^2.6.1", "nyc": "^15.0.0", "patch-package": "^6.4.7", diff --git a/patches/eth-query+2.1.2.patch b/patches/eth-query+2.1.2.patch index ea405d5f8f03..5ab82b6d5202 100644 --- a/patches/eth-query+2.1.2.patch +++ b/patches/eth-query+2.1.2.patch @@ -1,5 +1,5 @@ diff --git a/node_modules/eth-query/index.js b/node_modules/eth-query/index.js -index 13e9f3c..303d703 100644 +index 13e9f3c..d714bb7 100644 --- a/node_modules/eth-query/index.js +++ b/node_modules/eth-query/index.js @@ -1,5 +1,6 @@ @@ -9,7 +9,7 @@ index 13e9f3c..303d703 100644 module.exports = EthQuery -@@ -63,7 +64,9 @@ EthQuery.prototype.submitHashrate = generateFnFor('eth_subm +@@ -63,7 +64,10 @@ EthQuery.prototype.submitHashrate = generateFnFor('eth_subm EthQuery.prototype.sendAsync = function(opts, cb){ const self = this @@ -17,6 +17,7 @@ index 13e9f3c..303d703 100644 + const payload = createPayload(opts) + debug('making request %o', payload) + self.currentProvider.sendAsync(payload, function(err, response){ ++ debug('got err = %o, response = %o', err, response) if (!err && response.error) err = new Error('EthQuery - RPC Error - '+response.error.message) if (err) return cb(err) cb(null, response.result) diff --git a/shared/constants/network.ts b/shared/constants/network.ts index 457b624283ae..89dbe4ec2237 100644 --- a/shared/constants/network.ts +++ b/shared/constants/network.ts @@ -210,6 +210,7 @@ export const CHAIN_IDS = { HARMONY: '0x63564c40', PALM: '0x2a15c308d', SEPOLIA: '0xaa36a7', + AURORA: '0x4e454152', } as const; /** @@ -232,6 +233,7 @@ export const OPTIMISM_DISPLAY_NAME = 'Optimism'; export const FANTOM_DISPLAY_NAME = 'Fantom Opera'; export const HARMONY_DISPLAY_NAME = 'Harmony Mainnet Shard 0'; export const PALM_DISPLAY_NAME = 'Palm'; +export const AURORA_DISPLAY_NAME = 'Aurora Mainnet'; export const infuraProjectId = process.env.INFURA_PROJECT_ID; export const getRpcUrl = ({ @@ -257,6 +259,7 @@ export const LOCALHOST_RPC_URL = 'http://localhost:8545'; */ export const CURRENCY_SYMBOLS = { ARBITRUM: 'ETH', + AURORA: 'Aurora ETH', AVALANCHE: 'AVAX', BNB: 'BNB', BUSD: 'BUSD', @@ -410,6 +413,7 @@ export const FTM_TOKEN_IMAGE_URL = './images/fantom-opera.svg'; export const HARMONY_ONE_TOKEN_IMAGE_URL = './images/harmony-one.svg'; export const OPTIMISM_TOKEN_IMAGE_URL = './images/optimism.svg'; export const PALM_TOKEN_IMAGE_URL = './images/palm.svg'; +export const AURORA_TOKEN_IMAGE_URL = './images/aurora.png'; export const INFURA_PROVIDER_TYPES = [ NETWORK_TYPES.MAINNET, @@ -505,6 +509,7 @@ export const CHAIN_ID_TO_NETWORK_IMAGE_URL_MAP = { [CHAIN_IDS.HARMONY]: HARMONY_ONE_TOKEN_IMAGE_URL, [CHAIN_IDS.OPTIMISM]: OPTIMISM_TOKEN_IMAGE_URL, [CHAIN_IDS.PALM]: PALM_TOKEN_IMAGE_URL, + [CHAIN_IDS.AURORA]: AURORA_TOKEN_IMAGE_URL, } as const; export const NETWORK_ID_TO_ETHERS_NETWORK_NAME_MAP = { @@ -861,6 +866,11 @@ export const BUYABLE_CHAINS_MAP: { SUPPORTED_CURRENCY_SYMBOLS.USDS, ], }, + [CHAIN_IDS.AURORA]: { + nativeCurrency: CURRENCY_SYMBOLS.AURORA, + network: 'aurora', + transakCurrencies: [SUPPORTED_CURRENCY_SYMBOLS.AURORA], + }, }; export const FEATURED_RPCS: RPCDefinition[] = [ @@ -874,6 +884,16 @@ export const FEATURED_RPCS: RPCDefinition[] = [ imageUrl: AETH_TOKEN_IMAGE_URL, }, }, + { + chainId: CHAIN_IDS.AURORA, + nickname: AURORA_DISPLAY_NAME, + rpcUrl: `https://aurora-mainnet.infura.io/v3/${infuraProjectId}`, + ticker: CURRENCY_SYMBOLS.AURORA, + rpcPrefs: { + blockExplorerUrl: 'https://aurorascan.dev/', + imageUrl: AURORA_TOKEN_IMAGE_URL, + }, + }, { chainId: CHAIN_IDS.AVALANCHE, nickname: AVALANCHE_DISPLAY_NAME, diff --git a/test/helpers/setup-helper.js b/test/helpers/setup-helper.js index 2c7a8299fe50..cb627c805cdc 100644 --- a/test/helpers/setup-helper.js +++ b/test/helpers/setup-helper.js @@ -12,6 +12,12 @@ global.chrome = { nock.disableNetConnect(); nock.enableNetConnect('localhost'); +if (typeof beforeEach === 'function') { + /* eslint-disable-next-line jest/require-top-level-describe */ + beforeEach(() => { + nock.cleanAll(); + }); +} // catch rejections that are still unhandled when tests exit const unhandledRejections = new Map(); diff --git a/test/jest/setup.js b/test/jest/setup.js index ae49888e5e9a..c0852092041c 100644 --- a/test/jest/setup.js +++ b/test/jest/setup.js @@ -1,4 +1,6 @@ // This file is for Jest-specific setup only and runs before our Jest tests. + +import nock from 'nock'; import '@testing-library/jest-dom'; jest.mock('webextension-polyfill', () => { @@ -8,3 +10,8 @@ jest.mock('webextension-polyfill', () => { }, }; }); + +/* eslint-disable-next-line jest/require-top-level-describe */ +beforeEach(() => { + nock.cleanAll(); +}); diff --git a/ui/components/component-library/base-avatar/base-avatar.scss b/ui/components/component-library/base-avatar/base-avatar.scss index 7ead0dafbc63..cf558da6f67c 100644 --- a/ui/components/component-library/base-avatar/base-avatar.scss +++ b/ui/components/component-library/base-avatar/base-avatar.scss @@ -23,6 +23,8 @@ height: var(--avatar-size); width: var(--avatar-size); + max-width: var(--avatar-size); + flex: 0 0 var(--avatar-size); border-radius: 100%; overflow: hidden; display: flex; diff --git a/ui/components/component-library/icon/icon.js b/ui/components/component-library/icon/icon.js index 9318c4706bf6..8b18b183a1eb 100644 --- a/ui/components/component-library/icon/icon.js +++ b/ui/components/component-library/icon/icon.js @@ -61,7 +61,7 @@ Icon.propTypes = { * Addition style properties to apply to the icon. * The Icon component uses inline styles to apply the icon's mask-image so be wary of overriding */ - style: PropTypes.style, + style: PropTypes.object, /** * Icon accepts all the props from Box */ diff --git a/ui/pages/swaps/swaps.util.test.js b/ui/pages/swaps/swaps.util.test.js index d263f55c22b1..e1e1038748ff 100644 --- a/ui/pages/swaps/swaps.util.test.js +++ b/ui/pages/swaps/swaps.util.test.js @@ -42,7 +42,7 @@ jest.mock('../../../shared/lib/storage-helpers', () => ({ })); describe('Swaps Util', () => { - afterAll(() => { + afterEach(() => { nock.cleanAll(); }); @@ -112,7 +112,7 @@ describe('Swaps Util', () => { }); describe('fetchTokens', () => { - beforeAll(() => { + beforeEach(() => { nock('https://swap.metaswap.codefi.network') .persist() .get('/networks/1/tokens') @@ -131,7 +131,7 @@ describe('Swaps Util', () => { }); describe('fetchAggregatorMetadata', () => { - beforeAll(() => { + beforeEach(() => { nock('https://swap.metaswap.codefi.network') .persist() .get('/networks/1/aggregatorMetadata') @@ -150,7 +150,7 @@ describe('Swaps Util', () => { }); describe('fetchTopAssets', () => { - beforeAll(() => { + beforeEach(() => { nock('https://swap.metaswap.codefi.network') .persist() .get('/networks/1/topAssets') diff --git a/yarn.lock b/yarn.lock index 32b18cf97b55..79ad448d4e76 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2265,15 +2265,10 @@ "@hapi/hoek" "6.x.x" "@hapi/joi" "15.x.x" -"@hapi/hoek@6.x.x", "@hapi/hoek@^6.2.0": - version "6.2.4" - resolved "https://registry.yarnpkg.com/@hapi/hoek/-/hoek-6.2.4.tgz#4b95fbaccbfba90185690890bdf1a2fbbda10595" - integrity sha512-HOJ20Kc93DkDVvjwHyHawPwPkX44sIrbXazAUDiUXaY2R9JwQGo2PhFfnQtdrsIe4igjG2fPgMra7NYw7qhy0A== - -"@hapi/hoek@8.x.x": - version "8.1.0" - resolved "https://registry.yarnpkg.com/@hapi/hoek/-/hoek-8.1.0.tgz#8f7627b23ed9bf67088fc7f9669e48c63ad421bd" - integrity sha512-b1J4jxYnW+n6lC91V6Pqg9imP9BZq0HNCeM+3sbXg05rQsE9cGYrKFpZjyztVesGmNRE6R+QaEoWGATeIiUVjA== +"@hapi/hoek@6.x.x", "@hapi/hoek@8.x.x", "@hapi/hoek@^6.2.0", "@hapi/hoek@^8.5.1": + version "8.5.1" + resolved "https://registry.yarnpkg.com/@hapi/hoek/-/hoek-8.5.1.tgz#fde96064ca446dec8c55a8c2f130957b070c6e06" + integrity sha512-yN7kbciD87WzLGc5539Tn0sApjyiGHAJgKvG9W8C7O+6c7qmoQMfVs0W4bX17eqz6C78QJqqFrtgdK5EWf6Qow== "@hapi/inert@^5.2.0": version "5.2.1" @@ -3603,11 +3598,16 @@ resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.1.2.tgz#e9e035b9b166ca0af657a7848eb2718f0f22f183" integrity sha512-KYRCASVTv6aeUi1tsF8/vpyR7zpfs3FUzy2Jqm+MU+LmUKhQ0y2FpfwqkCcxSg2ua4GALJd8k2R76WxwZGbQpA== -"@noble/secp256k1@1.6.3", "@noble/secp256k1@^1.5.5", "@noble/secp256k1@~1.6.0": +"@noble/secp256k1@1.6.3", "@noble/secp256k1@~1.6.0": version "1.6.3" resolved "https://registry.yarnpkg.com/@noble/secp256k1/-/secp256k1-1.6.3.tgz#7eed12d9f4404b416999d0c87686836c4c5c9b94" integrity sha512-T04e4iTurVy7I8Sw4+c5OSN9/RkPlo1uKxAomtxQNLq8j1uPAqnsqG1bqvY3Jv7c13gyr6dui0zmh/I3+f/JaQ== +"@noble/secp256k1@^1.5.5", "@noble/secp256k1@^1.7.0": + version "1.7.0" + resolved "https://registry.yarnpkg.com/@noble/secp256k1/-/secp256k1-1.7.0.tgz#d15357f7c227e751d90aa06b05a0e5cf993ba8c1" + integrity sha512-kbacwGSsH/CTout0ZnZWxnW1B+jH/7r/WAAKLBtrRJ/+CUH7lgmQzl3GTrQua3SGKWNSDsS6lmjnDpIJ5Dxyaw== + "@nodelib/fs.scandir@2.1.3": version "2.1.3" resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.3.tgz#3a582bdb53804c6ba6d146579c46e52130cf4a3b" @@ -7114,7 +7114,7 @@ assert@^2.0.0: object-is "^1.0.1" util "^0.12.0" -assertion-error@^1.0.1, assertion-error@^1.1.0: +assertion-error@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b" integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw== @@ -8778,15 +8778,6 @@ chai-checkmark@^1.0.1: resolved "https://registry.yarnpkg.com/chai-checkmark/-/chai-checkmark-1.0.1.tgz#9fbb3c9ad9101f097ef288328d30f4227d74fffb" integrity sha1-n7s8mtkQHwl+8ogyjTD0In10//s= -"chai@>=1.9.2 <4.0.0": - version "3.5.0" - resolved "https://registry.yarnpkg.com/chai/-/chai-3.5.0.tgz#4d02637b067fe958bdbfdd3a40ec56fef7373247" - integrity sha1-TQJjewZ/6Vi9v906QOxW/vc3Mkc= - dependencies: - assertion-error "^1.0.1" - deep-eql "^0.1.3" - type-detect "^1.0.0" - chai@^4.3.4: version "4.3.4" resolved "https://registry.yarnpkg.com/chai/-/chai-4.3.4.tgz#b55e655b31e1eac7099be4c08c21964fce2e6c49" @@ -9444,7 +9435,7 @@ component-emitter@1.2.1: resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.2.1.tgz#137918d6d78283f7df7a6b7c5a63e140e69425e6" integrity sha1-E3kY1teCg/ffemt8WmPhQOaUJeY= -component-emitter@^1.2.0, component-emitter@^1.2.1, component-emitter@^1.3.0, component-emitter@~1.3.0: +component-emitter@^1.2.0, component-emitter@^1.2.1, component-emitter@~1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0" integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg== @@ -9663,7 +9654,7 @@ cookie@~0.4.1: resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.4.1.tgz#afd713fe26ebd21ba95ceb61f9a8116e50a537d1" integrity sha512-ZwrFkGJxUR3EIoXtO+yVE69Eb7KlixbaeAWfBQB9vVsNn/o+Yw69gBWSSDK825hQNdN+wF8zELf3dFNl/kxkUA== -cookiejar@^2.1.0, cookiejar@^2.1.1, cookiejar@^2.1.3: +cookiejar@^2.1.0, cookiejar@^2.1.1: version "2.1.3" resolved "https://registry.yarnpkg.com/cookiejar/-/cookiejar-2.1.3.tgz#fc7a6216e408e74414b90230050842dacda75acc" integrity sha512-JxbCBUdrfr6AQjOXrxoTvAMJO4HBTUIlBzslcJPAz+/KT8yk53fXun51u+RenNYvad/+Vc2DIz5o9UxlCDymFQ== @@ -10341,13 +10332,6 @@ dedent@^0.7.0: resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c" integrity sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw= -deep-eql@^0.1.3: - version "0.1.3" - resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-0.1.3.tgz#ef558acab8de25206cd713906d74e56930eb69f2" - integrity sha1-71WKyrjeJSBs1xOQbXTlaTDrafI= - dependencies: - type-detect "0.1.1" - deep-eql@^3.0.1: version "3.0.1" resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-3.0.1.tgz#dfc9404400ad1c8fe023e7da1df1c147c4b444df" @@ -10355,7 +10339,7 @@ deep-eql@^3.0.1: dependencies: type-detect "^4.0.0" -deep-equal@^1.0.0, deep-equal@^1.1.0: +deep-equal@^1.1.0: version "1.1.1" resolved "https://registry.yarnpkg.com/deep-equal/-/deep-equal-1.1.1.tgz#b5c98c942ceffaf7cb051e24e1434a25a2e6076a" integrity sha512-yd9c5AdiqVcR+JjcwUQb9DkhJc8ngNr0MahEBGvDiJw8puWab2yZlh+nkasOnZP+EGTAP6rRp2JzJhJZzvNF8g== @@ -10772,7 +10756,7 @@ detective@^5.2.0: defined "^1.0.0" minimist "^1.1.1" -dezalgo@1.0.3, dezalgo@^1.0.0: +dezalgo@^1.0.0: version "1.0.3" resolved "https://registry.yarnpkg.com/dezalgo/-/dezalgo-1.0.3.tgz#7f742de066fc748bc8db820569dddce49bf0d456" integrity sha512-K7i4zNfT2kgQz3GylDw40ot9GAE47sFZ9EXHFSPP6zONLgH6kWXE0KWJchkbQJLBkRazq4APwZ4OwiFFlT95OQ== @@ -12134,18 +12118,17 @@ eth-keyring-controller@^7.0.2: eth-simple-keyring "^4.2.0" obs-store "^4.0.3" -eth-lattice-keyring@^0.12.0: - version "0.12.0" - resolved "https://registry.yarnpkg.com/eth-lattice-keyring/-/eth-lattice-keyring-0.12.0.tgz#d71bfd2dec031de2b63fc45a8c19d22953e82a3d" - integrity sha512-f3w1H3nRbwi5gD/ivdeLlAv3mC5/bGigwHM7WRGV99pDi8nVLxaQQx11n+XFB5f7/4CcNNi0gbFP6JJurN2oRw== +eth-lattice-keyring@^0.12.3: + version "0.12.3" + resolved "https://registry.yarnpkg.com/eth-lattice-keyring/-/eth-lattice-keyring-0.12.3.tgz#32ee3db427d15f1d76f907a36ddc34f4aab205ba" + integrity sha512-Z7HBEVx7RkbQXoITO1pjZqdliCti3UpjO5ClETA/V4iqIz3VnAeub1LHRcEGBDv5EaDNnHJZmz7drLth2609Kw== dependencies: - "@ethereumjs/common" "2.4.0" "@ethereumjs/tx" "3.3.0" + "@ethereumjs/util" "^8.0.0" + "@noble/secp256k1" "^1.7.0" bn.js "^5.2.0" - ethereumjs-util "^7.0.10" - gridplus-sdk "^2.2.7" + gridplus-sdk "^2.2.9" rlp "^3.0.0" - secp256k1 "4.0.2" eth-lib@0.2.8: version "0.2.8" @@ -13082,7 +13065,7 @@ fast-redact@^3.0.0: resolved "https://registry.yarnpkg.com/fast-redact/-/fast-redact-3.1.1.tgz#790fcff8f808c2e12fabbfb2be5cb2deda448fa0" integrity sha512-odVmjC8x8jNeMZ3C+rPMESzXVSEU8tSWSHv9HFxP2mm89G/1WwqhrerJDQm9Zus8X6aoRgQDThKqptdNA6bt+A== -fast-safe-stringify@^2.0.6, fast-safe-stringify@^2.0.7, fast-safe-stringify@^2.1.1: +fast-safe-stringify@^2.0.6, fast-safe-stringify@^2.0.7: version "2.1.1" resolved "https://registry.yarnpkg.com/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz#c406a83b6e70d9e35ce3b30a81141df30aeba884" integrity sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA== @@ -13594,16 +13577,6 @@ formidable@^1.2.0: resolved "https://registry.yarnpkg.com/formidable/-/formidable-1.2.1.tgz#70fb7ca0290ee6ff961090415f4b3df3d2082659" integrity sha512-Fs9VRguL0gqGHkXS5GQiMCr1VhZBxz0JnJs4JmMp/2jL18Fmbzvv7vOFRU+U8TBkHEE/CX1qDXzJplVULgsLeg== -formidable@^2.0.1: - version "2.0.1" - resolved "https://registry.yarnpkg.com/formidable/-/formidable-2.0.1.tgz#4310bc7965d185536f9565184dee74fbb75557ff" - integrity sha512-rjTMNbp2BpfQShhFbR3Ruk3qk2y9jKpvMW78nJgx8QKtxjDVrwbZG+wvDOmVbifHyOUOQJXxqEy6r0faRrPzTQ== - dependencies: - dezalgo "1.0.3" - hexoid "1.0.0" - once "1.4.0" - qs "6.9.3" - forwarded@~0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/forwarded/-/forwarded-0.1.2.tgz#98c23dab1175657b8c0573e8ceccd91b0ff18c84" @@ -14415,10 +14388,10 @@ graphviz@0.0.9: dependencies: temp "~0.4.0" -gridplus-sdk@^2.2.7: - version "2.2.7" - resolved "https://registry.yarnpkg.com/gridplus-sdk/-/gridplus-sdk-2.2.7.tgz#d916b25a77358aed8d6fc5f1ed887ba32d51efb4" - integrity sha512-acpMxOkqubJRGcCRrYm1DA40utwIATjpWj/Wyismw16nAF3wGeQ79zUo5KwddtA+OYcwmqfPQMaAQ58qE0VpYg== +gridplus-sdk@^2.2.9: + version "2.2.9" + resolved "https://registry.yarnpkg.com/gridplus-sdk/-/gridplus-sdk-2.2.9.tgz#bd98257fee13d82e19ee267dfa21cd12f81eea21" + integrity sha512-U39YxeLisEJmw9KCtKCQB6C8UTVRKTonhDxwcDpN8T23VZuxk2SOzdmvq/HS01l5N+p1QEKKzQF6OCFQ7nVcYA== dependencies: "@ethereumjs/common" "2.4.0" "@ethereumjs/tx" "3.3.0" @@ -14436,7 +14409,6 @@ gridplus-sdk@^2.2.7: js-sha3 "^0.8.0" rlp "^3.0.0" secp256k1 "4.0.2" - superagent "^7.1.3" growl@1.10.5: version "1.10.5" @@ -14928,11 +14900,6 @@ heap@~0.2.6: resolved "https://registry.yarnpkg.com/heap/-/heap-0.2.6.tgz#087e1f10b046932fc8594dd9e6d378afc9d1e5ac" integrity sha1-CH4fELBGky/IWU3Z5tN4r8nR5aw= -hexoid@1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/hexoid/-/hexoid-1.0.0.tgz#ad10c6573fb907de23d9ec63a711267d9dc9bc18" - integrity sha512-QFLV0taWQOZtvIRIAdBChesmogZrtuXvVWsFHZTk2SU+anspqZ2vMnoLg7IE1+Uk16N19APic1BuF8bC8c2m5g== - hi-base32@~0.5.0: version "0.5.0" resolved "https://registry.yarnpkg.com/hi-base32/-/hi-base32-0.5.0.tgz#61329f76a31f31008533f1c36f2473e259d64571" @@ -19241,7 +19208,7 @@ lodash.uniqby@^4.7.0: resolved "https://registry.yarnpkg.com/lodash.uniqby/-/lodash.uniqby-4.7.0.tgz#d99c07a669e9e6d24e1362dfe266c67616af1302" integrity sha1-2ZwHpmnp5tJOE2Lf4mbGdhavEwI= -lodash@=3.10.1, lodash@^4.13.1, lodash@^4.16.4, lodash@^4.17.10, lodash@^4.17.11, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21, lodash@^4.17.4, lodash@^4.17.5, lodash@^4.2.0, lodash@~4.17.2: +lodash@=3.10.1, lodash@^4.13.1, lodash@^4.16.4, lodash@^4.17.10, lodash@^4.17.11, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21, lodash@^4.17.4, lodash@^4.17.5, lodash@^4.2.0: version "4.17.21" resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== @@ -19828,7 +19795,7 @@ mersenne-twister@^1.0.1, mersenne-twister@^1.1.0: resolved "https://registry.yarnpkg.com/mersenne-twister/-/mersenne-twister-1.1.0.tgz#f916618ee43d7179efcf641bec4531eb9670978a" integrity sha1-+RZhjuQ9cXnvz2Qb7EUx65Zwl4o= -methods@^1.1.1, methods@^1.1.2, methods@~1.1.2: +methods@^1.1.1, methods@~1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee" integrity sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w== @@ -19926,7 +19893,7 @@ mime@1.6.0, mime@^1.4.1: resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1" integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg== -mime@2.6.0, mime@^2.4.4: +mime@^2.4.4: version "2.6.0" resolved "https://registry.yarnpkg.com/mime/-/mime-2.6.0.tgz#a2a682a95cd4d0cb1d6257e28f83da7e35800367" integrity sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg== @@ -20100,7 +20067,7 @@ mkdirp-classic@^0.5.2, mkdirp-classic@^0.5.3: resolved "https://registry.yarnpkg.com/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz#fa10c9115cc6d8865be221ba47ee9bed78601113" integrity sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A== -mkdirp@0.5.5, mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@^0.5.3, mkdirp@^0.5.4, mkdirp@^0.5.5, mkdirp@~0.5.1: +mkdirp@0.5.5, mkdirp@^0.5.1, mkdirp@^0.5.3, mkdirp@^0.5.4, mkdirp@^0.5.5, mkdirp@~0.5.1: version "0.5.5" resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def" integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ== @@ -20678,20 +20645,15 @@ no-case@^3.0.3, no-case@^3.0.4: lower-case "^2.0.2" tslib "^2.0.3" -nock@^9.0.14: - version "9.1.5" - resolved "https://registry.yarnpkg.com/nock/-/nock-9.1.5.tgz#9e4878e0e1c050bdd93ae1e326e89461ea15618b" - integrity sha512-ukkBUhGU73CmSKTpTl6N/Qjvb7Hev4rCEjgOuEBKvHmsOqz7jGh2vUXL3dPnX3ndfcmVjsFBPfKpNuJbK94SKg== +nock@^13.2.9: + version "13.2.9" + resolved "https://registry.yarnpkg.com/nock/-/nock-13.2.9.tgz#4faf6c28175d36044da4cfa68e33e5a15086ad4c" + integrity sha512-1+XfJNYF1cjGB+TKMWi29eZ0b82QOvQs2YoLNzbpWGqFMtRQHTa57osqdGj4FrFPgkO4D4AZinzUJR9VvW3QUA== dependencies: - chai ">=1.9.2 <4.0.0" - debug "^2.2.0" - deep-equal "^1.0.0" + debug "^4.1.0" json-stringify-safe "^5.0.1" - lodash "~4.17.2" - mkdirp "^0.5.0" - propagate "0.4.0" - qs "^6.5.1" - semver "^5.3.0" + lodash "^4.17.21" + propagate "^2.0.0" node-abi@^2.18.0, node-abi@^2.21.0, node-abi@^2.7.0: version "2.30.1" @@ -21338,7 +21300,7 @@ on-headers@~1.0.2: resolved "https://registry.yarnpkg.com/on-headers/-/on-headers-1.0.2.tgz#772b0ae6aaa525c399e489adfad90c403eb3c28f" integrity sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA== -once@1.4.0, once@^1.3.0, once@^1.3.1, once@^1.3.2, once@^1.3.3, once@^1.4.0: +once@^1.3.0, once@^1.3.1, once@^1.3.2, once@^1.3.3, once@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E= @@ -23126,10 +23088,10 @@ prop-types@^15.0.0, prop-types@^15.5.10, prop-types@^15.5.6, prop-types@^15.5.7, object-assign "^4.1.1" react-is "^16.13.1" -propagate@0.4.0: - version "0.4.0" - resolved "https://registry.yarnpkg.com/propagate/-/propagate-0.4.0.tgz#f3fcca0a6fe06736a7ba572966069617c130b481" - integrity sha1-8/zKCm/gZzanulcpZgaWF8EwtIE= +propagate@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/propagate/-/propagate-2.0.1.tgz#40cdedab18085c792334e64f0ac17256d38f9a45" + integrity sha512-vGrhOavPSTz4QVNuBNdcNXePNdNMaO1xj9yBeH1ScQPjk/rhg9sSlCXPhMkFuaNNW/syTvYqsnbIJxMBfRbbag== proper-lockfile@^4.0.0: version "4.1.1" @@ -23535,17 +23497,12 @@ qs@6.7.0: resolved "https://registry.yarnpkg.com/qs/-/qs-6.7.0.tgz#41dc1a015e3d581f1621776be31afb2876a9b1bc" integrity sha512-VCdBRNFTX1fyE7Nb6FYoURo/SPe62QCaAyzJvUjwRaIsc+NePBEniHlvxFmmX56+HZphIGtV0XeCirBtpDrTyQ== -qs@6.9.3: - version "6.9.3" - resolved "https://registry.yarnpkg.com/qs/-/qs-6.9.3.tgz#bfadcd296c2d549f1dffa560619132c977f5008e" - integrity sha512-EbZYNarm6138UKKq46tdx08Yo/q9ZhFoAXAI1meAFd2GtbRDhbZY2WQSICskT0c5q99aFzLG1D4nvTk9tqfXIw== - qs@6.9.6: version "6.9.6" resolved "https://registry.yarnpkg.com/qs/-/qs-6.9.6.tgz#26ed3c8243a431b2924aca84cc90471f35d5a0ee" integrity sha512-TIRk4aqYLNoJUbd+g2lEdz5kLWIuTMRagAXxl78Q0RiVjAOugHmeKNGdd3cwo/ktpf9aL9epCfFqWDEKysUlLQ== -qs@^6.10.0, qs@^6.10.3, qs@^6.4.0, qs@^6.5.1, qs@^6.5.2: +qs@^6.10.0, qs@^6.4.0, qs@^6.5.1, qs@^6.5.2: version "6.11.0" resolved "https://registry.yarnpkg.com/qs/-/qs-6.11.0.tgz#fd0d963446f7a65e1367e01abd85429453f0c37a" integrity sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q== @@ -26732,23 +26689,6 @@ superagent@^3.8.1: qs "^6.5.1" readable-stream "^2.3.5" -superagent@^7.1.3: - version "7.1.6" - resolved "https://registry.yarnpkg.com/superagent/-/superagent-7.1.6.tgz#64f303ed4e4aba1e9da319f134107a54cacdc9c6" - integrity sha512-gZkVCQR1gy/oUXr+kxJMLDjla434KmSOKbx5iGD30Ql+AkJQ/YlPKECJy2nhqOsHLjGHzoDTXNSjhnvWhzKk7g== - dependencies: - component-emitter "^1.3.0" - cookiejar "^2.1.3" - debug "^4.3.4" - fast-safe-stringify "^2.1.1" - form-data "^4.0.0" - formidable "^2.0.1" - methods "^1.1.2" - mime "2.6.0" - qs "^6.10.3" - readable-stream "^3.6.0" - semver "^7.3.7" - superstruct@^0.16.0: version "0.16.0" resolved "https://registry.yarnpkg.com/superstruct/-/superstruct-0.16.0.tgz#9af5e059acd08e774789ad8880962427ef68dace" @@ -27592,21 +27532,11 @@ type-check@~0.3.2: dependencies: prelude-ls "~1.1.2" -type-detect@0.1.1: - version "0.1.1" - resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-0.1.1.tgz#0ba5ec2a885640e470ea4e8505971900dac58822" - integrity sha1-C6XsKohWQORw6k6FBZcZANrFiCI= - type-detect@4.0.8, type-detect@^4.0.0, type-detect@^4.0.5, type-detect@^4.0.8: version "4.0.8" resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c" integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== -type-detect@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-1.0.0.tgz#762217cc06db258ec48908a1298e8b95121e8ea2" - integrity sha1-diIXzAbbJY7EiQihKY6LlRIejqI= - type-fest@^0.13.1: version "0.13.1" resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.13.1.tgz#0172cb5bce80b0bd542ea348db50c7e21834d934"