@diwantanushh/rapiddex-contracts 1.0.0

package/lib/openzeppelin-contracts-master/test/utils/structs/Heap.t.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {Heap} from "@openzeppelin/contracts/utils/structs/Heap.sol";
+import {Comparators} from "@openzeppelin/contracts/utils/Comparators.sol";
+
+contract Uint256HeapTest is Test {
+    using Heap for Heap.Uint256Heap;
+
+    Heap.Uint256Heap internal heap;
+
+    function _validateHeap(function(uint256, uint256) view returns (bool) comp) internal view {
+        for (uint32 i = 1; i < heap.length(); ++i) {
+            assertFalse(comp(heap.tree[i], heap.tree[(i - 1) / 2]));
+        }
+    }
+
+    function testFuzz(uint256[] calldata input) public {
+        vm.assume(input.length < 0x20);
+        assertEq(heap.length(), 0);
+
+        uint256 min = type(uint256).max;
+        for (uint256 i = 0; i < input.length; ++i) {
+            heap.insert(input[i]);
+            assertEq(heap.length(), i + 1);
+            _validateHeap(Comparators.lt);
+
+            min = Math.min(min, input[i]);
+            assertEq(heap.peek(), min);
+        }
+
+        uint256 max = 0;
+        for (uint256 i = 0; i < input.length; ++i) {
+            uint256 top = heap.peek();
+            uint256 pop = heap.pop();
+            assertEq(heap.length(), input.length - i - 1);
+            _validateHeap(Comparators.lt);
+
+            assertEq(pop, top);
+            assertGe(pop, max);
+            max = pop;
+        }
+    }
+
+    function testFuzzGt(uint256[] calldata input) public {
+        vm.assume(input.length < 0x20);
+        assertEq(heap.length(), 0);
+
+        uint256 max = 0;
+        for (uint256 i = 0; i < input.length; ++i) {
+            heap.insert(input[i], Comparators.gt);
+            assertEq(heap.length(), i + 1);
+            _validateHeap(Comparators.gt);
+
+            max = Math.max(max, input[i]);
+            assertEq(heap.peek(), max);
+        }
+
+        uint256 min = type(uint256).max;
+        for (uint256 i = 0; i < input.length; ++i) {
+            uint256 top = heap.peek();
+            uint256 pop = heap.pop(Comparators.gt);
+            assertEq(heap.length(), input.length - i - 1);
+            _validateHeap(Comparators.gt);
+
+            assertEq(pop, top);
+            assertLe(pop, min);
+            min = pop;
+        }
+    }
+}

package/lib/openzeppelin-contracts-master/test/utils/structs/Heap.test.js

@@ -0,0 +1,113 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
+
+async function fixture() {
+  const mock = await ethers.deployContract('$Heap');
+  return { mock };
+}
+
+describe('Heap', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('Uint256Heap', function () {
+    it('starts empty', async function () {
+      expect(await this.mock.$length(0)).to.equal(0n);
+    });
+
+    it('peek, pop and replace from empty', async function () {
+      await expect(this.mock.$peek(0)).to.be.revertedWithPanic(PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS);
+      await expect(this.mock.$pop(0)).to.be.revertedWithPanic(PANIC_CODES.POP_ON_EMPTY_ARRAY);
+      await expect(this.mock.$replace(0, 0n)).to.be.revertedWithPanic(PANIC_CODES.POP_ON_EMPTY_ARRAY);
+    });
+
+    it('clear', async function () {
+      await this.mock.$insert(0, 42n);
+
+      expect(await this.mock.$length(0)).to.equal(1n);
+      expect(await this.mock.$peek(0)).to.equal(42n);
+
+      await this.mock.$clear(0);
+
+      expect(await this.mock.$length(0)).to.equal(0n);
+      await expect(this.mock.$peek(0)).to.be.revertedWithPanic(PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS);
+    });
+
+    it('support duplicated items', async function () {
+      expect(await this.mock.$length(0)).to.equal(0n);
+
+      // insert 5 times
+      await this.mock.$insert(0, 42n);
+      await this.mock.$insert(0, 42n);
+      await this.mock.$insert(0, 42n);
+      await this.mock.$insert(0, 42n);
+      await this.mock.$insert(0, 42n);
+
+      // pop 5 times
+      await expect(this.mock.$pop(0)).to.emit(this.mock, 'return$pop').withArgs(42n);
+      await expect(this.mock.$pop(0)).to.emit(this.mock, 'return$pop').withArgs(42n);
+      await expect(this.mock.$pop(0)).to.emit(this.mock, 'return$pop').withArgs(42n);
+      await expect(this.mock.$pop(0)).to.emit(this.mock, 'return$pop').withArgs(42n);
+      await expect(this.mock.$pop(0)).to.emit(this.mock, 'return$pop').withArgs(42n);
+
+      // popping a 6th time panics
+      await expect(this.mock.$pop(0)).to.be.revertedWithPanic(PANIC_CODES.POP_ON_EMPTY_ARRAY);
+    });
+
+    it('insert, pop and replace', async function () {
+      const heap = [];
+      for (const { op, value } of [
+        { op: 'insert', value: 712 }, // [712]
+        { op: 'insert', value: 20 }, // [20, 712]
+        { op: 'insert', value: 4337 }, // [20, 712, 4337]
+        { op: 'pop' }, // 20, [712, 4337]
+        { op: 'insert', value: 1559 }, // [712, 1559, 4337]
+        { op: 'insert', value: 165 }, // [165, 712, 1559, 4337]
+        { op: 'insert', value: 155 }, // [155, 165, 712, 1559, 4337]
+        { op: 'insert', value: 7702 }, // [155, 165, 712, 1559, 4337, 7702]
+        { op: 'pop' }, // 155, [165, 712, 1559, 4337, 7702]
+        { op: 'replace', value: 721 }, // 165, [712, 721, 1559, 4337, 7702]
+        { op: 'pop' }, // 712, [721, 1559, 4337, 7702]
+        { op: 'pop' }, // 721, [1559, 4337, 7702]
+        { op: 'pop' }, // 1559, [4337, 7702]
+        { op: 'pop' }, // 4337, [7702]
+        { op: 'pop' }, // 7702, []
+        { op: 'pop' }, // panic
+        { op: 'replace', value: '1363' }, // panic
+      ]) {
+        switch (op) {
+          case 'insert':
+            await this.mock.$insert(0, value);
+            heap.push(value);
+            heap.sort((a, b) => a - b);
+            break;
+          case 'pop':
+            if (heap.length == 0) {
+              await expect(this.mock.$pop(0)).to.be.revertedWithPanic(PANIC_CODES.POP_ON_EMPTY_ARRAY);
+            } else {
+              await expect(this.mock.$pop(0)).to.emit(this.mock, 'return$pop').withArgs(heap.shift());
+            }
+            break;
+          case 'replace':
+            if (heap.length == 0) {
+              await expect(this.mock.$replace(0, value)).to.be.revertedWithPanic(PANIC_CODES.POP_ON_EMPTY_ARRAY);
+            } else {
+              await expect(this.mock.$replace(0, value)).to.emit(this.mock, 'return$replace').withArgs(heap.shift());
+              heap.push(value);
+              heap.sort((a, b) => a - b);
+            }
+            break;
+        }
+        expect(await this.mock.$length(0)).to.equal(heap.length);
+        if (heap.length == 0) {
+          await expect(this.mock.$peek(0)).to.be.revertedWithPanic(PANIC_CODES.ARRAY_ACCESS_OUT_OF_BOUNDS);
+        } else {
+          expect(await this.mock.$peek(0)).to.equal(heap[0]);
+        }
+      }
+    });
+  });
+});

package/lib/openzeppelin-contracts-master/test/utils/structs/MerkleTree.test.js

@@ -0,0 +1,180 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic');
+const { StandardMerkleTree } = require('@openzeppelin/merkle-tree');
+
+const { generators } = require('../../helpers/random');
+const { range } = require('../../helpers/iterate');
+
+const DEPTH = 4; // 16 slots
+
+const makeTree = (leaves = [], length = 2 ** DEPTH, zero = ethers.ZeroHash) =>
+  StandardMerkleTree.of(
+    []
+      .concat(
+        leaves,
+        Array.from({ length: length - leaves.length }, () => zero),
+      )
+      .map(leaf => [leaf]),
+    ['bytes32'],
+    { sortLeaves: false },
+  );
+
+const ZERO = makeTree().leafHash([ethers.ZeroHash]);
+
+async function fixture() {
+  const mock = await ethers.deployContract('MerkleTreeMock');
+  await mock.setup(DEPTH, ZERO);
+  return { mock };
+}
+
+describe('MerkleTree', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  it('sets initial values at setup', async function () {
+    const merkleTree = makeTree();
+
+    await expect(this.mock.root()).to.eventually.equal(merkleTree.root);
+    await expect(this.mock.depth()).to.eventually.equal(DEPTH);
+    await expect(this.mock.nextLeafIndex()).to.eventually.equal(0n);
+  });
+
+  describe('push', function () {
+    it('pushing correctly updates the tree', async function () {
+      const leaves = [];
+
+      // for each leaf slot
+      for (const i in range(2 ** DEPTH)) {
+        // generate random leaf
+        leaves.push(generators.bytes32());
+
+        // rebuild tree.
+        const tree = makeTree(leaves);
+        const hash = tree.leafHash(tree.at(i));
+
+        // push value to tree
+        await expect(this.mock.push(hash)).to.emit(this.mock, 'LeafInserted').withArgs(hash, i, tree.root);
+
+        // check tree
+        await expect(this.mock.root()).to.eventually.equal(tree.root);
+        await expect(this.mock.nextLeafIndex()).to.eventually.equal(BigInt(i) + 1n);
+      }
+    });
+
+    it('pushing to a full tree reverts', async function () {
+      await Promise.all(Array.from({ length: 2 ** Number(DEPTH) }).map(() => this.mock.push(ethers.ZeroHash)));
+
+      await expect(this.mock.push(ethers.ZeroHash)).to.be.revertedWithPanic(PANIC_CODES.TOO_MUCH_MEMORY_ALLOCATED);
+    });
+  });
+
+  describe('update', function () {
+    for (const { leafCount, leafIndex } of range(2 ** DEPTH + 1).flatMap(leafCount =>
+      range(leafCount).map(leafIndex => ({ leafCount, leafIndex })),
+    ))
+      it(`updating a leaf correctly updates the tree (leaf #${leafIndex + 1}/${leafCount})`, async function () {
+        // initial tree
+        const leaves = Array.from({ length: leafCount }, generators.bytes32);
+        const oldTree = makeTree(leaves);
+
+        // fill tree and verify root
+        for (const i in leaves) {
+          await this.mock.push(oldTree.leafHash(oldTree.at(i)));
+        }
+        await expect(this.mock.root()).to.eventually.equal(oldTree.root);
+
+        // create updated tree
+        leaves[leafIndex] = generators.bytes32();
+        const newTree = makeTree(leaves);
+
+        const oldLeafHash = oldTree.leafHash(oldTree.at(leafIndex));
+        const newLeafHash = newTree.leafHash(newTree.at(leafIndex));
+
+        // perform update
+        await expect(this.mock.update(leafIndex, oldLeafHash, newLeafHash, oldTree.getProof(leafIndex)))
+          .to.emit(this.mock, 'LeafUpdated')
+          .withArgs(oldLeafHash, newLeafHash, leafIndex, newTree.root);
+
+        // verify updated root
+        await expect(this.mock.root()).to.eventually.equal(newTree.root);
+
+        // if there is still room in the tree, fill it
+        for (const i of range(leafCount, 2 ** DEPTH)) {
+          // push new value and rebuild tree
+          leaves.push(generators.bytes32());
+          const nextTree = makeTree(leaves);
+
+          // push and verify root
+          await this.mock.push(nextTree.leafHash(nextTree.at(i)));
+          await expect(this.mock.root()).to.eventually.equal(nextTree.root);
+        }
+      });
+
+    it('replacing a leaf that was not previously pushed reverts', async function () {
+      // changing leaf 0 on an empty tree
+      await expect(this.mock.update(1, ZERO, ZERO, []))
+        .to.be.revertedWithCustomError(this.mock, 'MerkleTreeUpdateInvalidIndex')
+        .withArgs(1, 0);
+    });
+
+    it('replacing a leaf using an invalid proof reverts', async function () {
+      const leafCount = 4;
+      const leafIndex = 2;
+
+      const leaves = Array.from({ length: leafCount }, generators.bytes32);
+      const tree = makeTree(leaves);
+
+      // fill tree and verify root
+      for (const i in leaves) {
+        await this.mock.push(tree.leafHash(tree.at(i)));
+      }
+      await expect(this.mock.root()).to.eventually.equal(tree.root);
+
+      const oldLeafHash = tree.leafHash(tree.at(leafIndex));
+      const newLeafHash = generators.bytes32();
+      const proof = tree.getProof(leafIndex);
+      // invalid proof (tamper)
+      proof[1] = generators.bytes32();
+
+      await expect(this.mock.update(leafIndex, oldLeafHash, newLeafHash, proof)).to.be.revertedWithCustomError(
+        this.mock,
+        'MerkleTreeUpdateInvalidProof',
+      );
+    });
+  });
+
+  it('reset', async function () {
+    // empty tree
+    const emptyTree = makeTree();
+
+    // tree with one element
+    const leaves = [generators.bytes32()];
+    const tree = makeTree(leaves);
+    const hash = tree.leafHash(tree.at(0));
+
+    // root should be that of a zero tree
+    expect(await this.mock.root()).to.equal(emptyTree.root);
+    expect(await this.mock.nextLeafIndex()).to.equal(0n);
+
+    // push leaf and check root
+    await expect(this.mock.push(hash)).to.emit(this.mock, 'LeafInserted').withArgs(hash, 0, tree.root);
+
+    expect(await this.mock.root()).to.equal(tree.root);
+    expect(await this.mock.nextLeafIndex()).to.equal(1n);
+
+    // reset tree
+    await this.mock.setup(DEPTH, ZERO);
+
+    expect(await this.mock.root()).to.equal(emptyTree.root);
+    expect(await this.mock.nextLeafIndex()).to.equal(0n);
+
+    // re-push leaf and check root
+    await expect(this.mock.push(hash)).to.emit(this.mock, 'LeafInserted').withArgs(hash, 0, tree.root);
+
+    expect(await this.mock.root()).to.equal(tree.root);
+    expect(await this.mock.nextLeafIndex()).to.equal(1n);
+  });
+});

package/lib/openzeppelin-contracts-master/test/utils/types/Time.test.js

@@ -0,0 +1,135 @@
+const { ethers } = require('hardhat');
+const { expect } = require('chai');
+const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers');
+
+const { product } = require('../../helpers/iterate');
+const { max } = require('../../helpers/math');
+const time = require('../../helpers/time');
+
+const MAX_UINT32 = (1n << 32n) - 1n;
+const MAX_UINT48 = (1n << 48n) - 1n;
+const SOME_VALUES = [0n, 1n, 2n, 15n, 16n, 17n, 42n];
+
+const asUint = (value, size) => {
+  value = ethers.toBigInt(value);
+  size = ethers.toBigInt(size);
+  expect(value).to.be.greaterThanOrEqual(0n, `value is not a valid uint${size}`);
+  expect(value).to.be.lessThan(1n << size, `value is not a valid uint${size}`);
+  return value;
+};
+
+const unpackDelay = delay => ({
+  valueBefore: (asUint(delay, 112) >> 32n) % (1n << 32n),
+  valueAfter: (asUint(delay, 112) >> 0n) % (1n << 32n),
+  effect: (asUint(delay, 112) >> 64n) % (1n << 48n),
+});
+
+const packDelay = ({ valueBefore, valueAfter = 0n, effect = 0n }) =>
+  (asUint(valueAfter, 32) << 0n) + (asUint(valueBefore, 32) << 32n) + (asUint(effect, 48) << 64n);
+
+const effectSamplesForTimepoint = timepoint => [
+  0n,
+  timepoint,
+  ...product([-1n, 1n], [1n, 2n, 17n, 42n])
+    .map(([sign, shift]) => timepoint + sign * shift)
+    .filter(effect => effect > 0n && effect <= MAX_UINT48),
+  MAX_UINT48,
+];
+
+async function fixture() {
+  const mock = await ethers.deployContract('$Time');
+  return { mock };
+}
+
+describe('Time', function () {
+  beforeEach(async function () {
+    Object.assign(this, await loadFixture(fixture));
+  });
+
+  describe('clocks', function () {
+    it('timestamp', async function () {
+      expect(await this.mock.$timestamp()).to.equal(await time.clock.timestamp());
+    });
+
+    it('block number', async function () {
+      expect(await this.mock.$blockNumber()).to.equal(await time.clock.blockNumber());
+    });
+  });
+
+  describe('Delay', function () {
+    describe('packing and unpacking', function () {
+      const valueBefore = 17n;
+      const valueAfter = 42n;
+      const effect = 69n;
+      const delay = 1272825341158973505578n;
+
+      it('pack', async function () {
+        expect(await this.mock.$pack(valueBefore, valueAfter, effect)).to.equal(delay);
+        expect(packDelay({ valueBefore, valueAfter, effect })).to.equal(delay);
+      });
+
+      it('unpack', async function () {
+        expect(await this.mock.$unpack(delay)).to.deep.equal([valueBefore, valueAfter, effect]);
+
+        expect(unpackDelay(delay)).to.deep.equal({
+          valueBefore,
+          valueAfter,
+          effect,
+        });
+      });
+    });
+
+    it('toDelay', async function () {
+      for (const value of [...SOME_VALUES, MAX_UINT32]) {
+        expect(await this.mock.$toDelay(value).then(unpackDelay)).to.deep.equal({
+          valueBefore: 0n,
+          valueAfter: value,
+          effect: 0n,
+        });
+      }
+    });
+
+    it('get & getFull', async function () {
+      const timepoint = await time.clock.timestamp();
+      const valueBefore = 24194n;
+      const valueAfter = 4214143n;
+
+      for (const effect of effectSamplesForTimepoint(timepoint)) {
+        const isPast = effect <= timepoint;
+        const delay = packDelay({ valueBefore, valueAfter, effect });
+
+        expect(await this.mock.$get(delay)).to.equal(isPast ? valueAfter : valueBefore);
+        expect(await this.mock.$getFull(delay)).to.deep.equal([
+          isPast ? valueAfter : valueBefore,
+          isPast ? 0n : valueAfter,
+          isPast ? 0n : effect,
+        ]);
+      }
+    });
+
+    it('withUpdate', async function () {
+      const timepoint = await time.clock.timestamp();
+      const valueBefore = 24194n;
+      const valueAfter = 4214143n;
+      const newvalueAfter = 94716n;
+
+      for (const effect of effectSamplesForTimepoint(timepoint))
+        for (const minSetback of [...SOME_VALUES, MAX_UINT32]) {
+          const isPast = effect <= timepoint;
+          const expectedvalueBefore = isPast ? valueAfter : valueBefore;
+          const expectedSetback = max(minSetback, expectedvalueBefore - newvalueAfter, 0n);
+
+          expect(
+            await this.mock.$withUpdate(packDelay({ valueBefore, valueAfter, effect }), newvalueAfter, minSetback),
+          ).to.deep.equal([
+            packDelay({
+              valueBefore: expectedvalueBefore,
+              valueAfter: newvalueAfter,
+              effect: timepoint + expectedSetback,
+            }),
+            timepoint + expectedSetback,
+          ]);
+        }
+    });
+  });
+});

package/lib/v3-core-main/.gitattributes

@@ -0,0 +1 @@
+*.sol linguist-language=Solidity

package/lib/v3-core-main/.github/stale.yml

@@ -0,0 +1,25 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+issues:
+  # Number of days of inactivity before an Issue or Pull Request becomes stale
+  daysUntilStale: 7
+
+  # Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
+  # Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
+  daysUntilClose: 7
+
+  # Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
+  onlyLabels:
+    - question
+    - autoclose
+
+  # Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
+  exemptLabels:
+    - p0
+    - bug
+
+  # Comment to post when marking as stale. Set to `false` to disable
+  markComment: >
+    This issue has been automatically marked as stale because it has not had
+    recent activity. It will be closed if no further activity occurs. Thank you
+    for your contributions.

package/lib/v3-core-main/.github/workflows/fuzz-testing.yml

@@ -0,0 +1,60 @@
+name: Fuzz Testing
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  echidna:
+    name: Echidna
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        testName:
+          - TickBitmapEchidnaTest
+          - TickMathEchidnaTest
+          - SqrtPriceMathEchidnaTest
+          - SwapMathEchidnaTest
+          - TickEchidnaTest
+          - TickOverflowSafetyEchidnaTest
+          - OracleEchidnaTest
+          - BitMathEchidnaTest
+          - LowGasSafeMathEchidnaTest
+          - UnsafeMathEchidnaTest
+          - FullMathEchidnaTest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up node
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Set up Python 3.8
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+
+      - name: Install node dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Install pip3
+        run: |
+          python -m pip install --upgrade pip
+
+      - name: Install slither
+        run: |
+          pip3 install slither-analyzer
+
+      - name: Install echidna
+        run: |
+          sudo wget -O /tmp/echidna-test.tar.gz https://github.com/crytic/echidna/releases/download/v1.6.0/echidna-test-v1.6.0-Ubuntu-18.04.tar.gz
+          sudo tar -xf /tmp/echidna-test.tar.gz -C /usr/bin
+          sudo chmod +x /usr/bin/echidna-test
+
+      - name: Run ${{ matrix.testName }}
+        run: echidna-test . --contract ${{ matrix.testName }} --config echidna.config.yml

package/lib/v3-core-main/.github/workflows/lint.yml

@@ -0,0 +1,34 @@
+name: Lint
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  run-linters:
+    name: Run linters
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out Git repository
+        uses: actions/checkout@v2
+
+      - name: Set up node
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile --ignore-scripts
+
+      - name: Run linters
+        uses: wearerequired/lint-action@a8497ddb33fb1205941fd40452ca9fff07e0770d
+        with:
+          prettier: true
+          auto_fix: false
+          prettier_extensions: 'css,html,js,json,jsx,md,sass,scss,ts,tsx,vue,yaml,yml,sol'

package/lib/v3-core-main/.github/workflows/mythx.yml

@@ -0,0 +1,65 @@
+name: Mythx
+
+on:
+  workflow_dispatch:
+
+jobs:
+  mythx:
+    name: Submit to Mythx
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up node
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Set up Python 3.8
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+
+      - name: Install node dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Install pip3
+        run: |
+          python -m pip install --upgrade pip
+
+      - name: Install mythx CLI
+        run: |
+          pip3 install mythx-cli
+
+      - name: Install solc-select
+        run: |
+          pip3 install solc-select
+
+      - name: Install solc 0.7.6
+        run: |
+          solc-select install 0.7.6
+          solc-select use 0.7.6
+
+      - name: Submit code to Mythx
+        run: |
+          mythx --api-key ${{ secrets.MYTHX_API_KEY }} \
+            --yes \
+            analyze \
+            --mode deep \
+            --async \
+            --create-group \
+            --group-name "@uniswap/v3-core@${{ github.sha }}" \
+            --solc-version 0.7.6 \
+            --check-properties \
+            contracts/test/TickBitmapEchidnaTest.sol --include TickBitmapEchidnaTest \
+            contracts/test/TickMathEchidnaTest.sol --include TickMathEchidnaTest \
+            contracts/test/SqrtPriceMathEchidnaTest.sol --include SqrtPriceMathEchidnaTest \
+            contracts/test/SwapMathEchidnaTest.sol --include SwapMathEchidnaTest \
+            contracts/test/TickEchidnaTest.sol --include TickEchidnaTest \
+            contracts/test/TickOverflowSafetyEchidnaTest.sol --include TickOverflowSafetyEchidnaTest \
+            contracts/test/OracleEchidnaTest.sol --include OracleEchidnaTest \
+            contracts/test/BitMathEchidnaTest.sol --include BitMathEchidnaTest \
+            contracts/test/LowGasSafeMathEchidnaTest.sol --include LowGasSafeMathEchidnaTest \
+            contracts/test/UnsafeMathEchidnaTest.sol --include UnsafeMathEchidnaTest \
+            contracts/test/FullMathEchidnaTest.sol --include FullMathEchidnaTest