test address packing

contracts/lens/AddressTester.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import '@uniswap/v3-periphery/contracts/base/PeripheryImmutableState.sol';
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Callee.sol';
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
+import '../libraries/UniswapV2Library.sol';
+import '../interfaces/ISwapRouter02.sol';
+import '../interfaces/ITokenValidator.sol';
+import '../base/ImmutableState.sol';
+import 'hardhat/console.sol';
+import './IAddressTester.sol';
+
+contract AddressTester is IAddressTester {
+    constructor() {}
+
+    function validate(address _addr) public override {
+        bytes32 a;
+        bytes32 b;
+        assembly {
+            a := calldataload(4)
+        }
+
+        console.logBytes32(a);
+
+        address addr = _addr;
+        bytes32 c;
+        assembly {
+            let ptr := mload(0x40)
+            c := mload(sub(ptr, 32))
+        }
+        console.logBytes32(c);
+    }
+}

contracts/lens/AddressTesterCaller.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import '@uniswap/v3-periphery/contracts/base/PeripheryImmutableState.sol';
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Callee.sol';
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
+import '../libraries/UniswapV2Library.sol';
+import '../interfaces/ISwapRouter02.sol';
+import '../interfaces/ITokenValidator.sol';
+import '../base/ImmutableState.sol';
+import 'hardhat/console.sol';
+import './IAddressTester.sol';
+
+contract AddressTesterCaller {
+    address tester;
+
+    constructor(address _tester) {
+        tester = _tester;
+    }
+
+    function validate() public returns (bool, bool) {
+        address usdc = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+
+        console.log('Calling Valid');
+        (bool success1, bytes memory data1) =
+            tester.call(hex'207c64fb000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2');
+
+        console.log('Calling with hidden Valid');
+        (bool success2, bytes memory data2) =
+            tester.call(hex'207c64fb00000000eeeeeeeeeeeeeeeec02aaa39b223fe8d0a0e5c4f27ead9083c756cc2');
+
+        console.logBool(success1);
+        console.logBool(success2);
+
+        require(success1, '1 failed');
+        require(success2, '2 failed');
+
+        return (success1, success2);
+    }
+}

contracts/lens/IAddressTester.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity =0.7.6;
+pragma abicoder v2;
+
+interface IAddressTester {
+    function validate(address _addr) external;
+}

hardhat.config.ts

@@ -23,6 +23,7 @@ export default {
   networks: {
     hardhat: {
       allowUnlimitedContractSize: false,
+      loggingEnabled: true,
     },
     mainnet: {
       url: `https://mainnet.infura.io/v3/${process.env.INFURA_API_KEY}`,

scripts/deploy.js

@@ -0,0 +1,72 @@
+const hre = require('hardhat')
+const ethers = hre.ethers
+
+async function main() {
+  // We get the contract to deploy
+  const AddressTester = await ethers.getContractFactory('AddressTester')
+
+  const AddressTesterCaller = await ethers.getContractFactory('AddressTesterCaller')
+
+  const addressTester = await AddressTester.deploy()
+  // const addressTester = AddressTester.attach('0x8e36F6e5214e69985BdB1A450aaBD0d6c1EB3e2b')
+  const addressTesterCaller = await AddressTesterCaller.deploy(addressTester.address)
+
+  console.log('AddressTester deployed to:', addressTester.address)
+  console.log('AddressTesterCaller deployed to:', addressTesterCaller.address)
+
+  const signer = (await ethers.getSigners())[0]
+
+  const calldata = addressTesterCaller.interface.encodeFunctionData('validate', [])
+
+  console.log(calldata)
+
+  await new Promise((resolve) => {
+    setTimeout(() => {
+      resolve()
+    }, 7500)
+  })
+
+  const r = await ethers.provider.send('eth_call', [
+    {
+      from: signer.address,
+      data: calldata,
+      to: addressTesterCaller.address,
+    },
+    'latest',
+  ])
+
+  console.log({ r }, 'RESULT')
+
+  //await addressTester.callStatic.validate('0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2')
+
+  // const calldata1 = '0x207c64fb000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+  // const calldata2 = '0x207c64fb00000000eeeeeeeeeeeeeeeec02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+
+  // console.log('x')
+  // // await signer.call({ data: calldata1, to: addressTester.address })
+  // await ethers.provider.send('eth_call', [
+  //   {
+  //     from: signer.address,
+  //     data: calldata1,
+  //     to: addressTester.address,
+  //   },
+  //   'latest',
+  // ])
+
+  // console.log('z')
+  // await ethers.provider.send('eth_call', [
+  //   {
+  //     from: signer.address,
+  //     data: calldata2,
+  //     to: addressTester.address,
+  //   },
+  //   'latest',
+  // ])
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error)
+    process.exit(1)
+  })

test/AddressTester.spec.ts

@@ -0,0 +1,61 @@
+import hre, { ethers } from 'hardhat'
+import { AddressTester, AddressTesterCaller } from '../typechain'
+
+describe('AddressTester', function () {
+  let addressTester: AddressTester
+  let addressTesterCaller: AddressTesterCaller
+
+  before(async function () {
+    if (!process.env.ARCHIVE_RPC_URL) {
+      this.skip()
+    }
+
+    await hre.network.provider.request({
+      method: 'hardhat_reset',
+      params: [
+        {
+          forking: {
+            jsonRpcUrl: process.env.ARCHIVE_RPC_URL,
+            blockNumber: 14256985,
+          },
+        },
+      ],
+    })
+
+    const factory = await ethers.getContractFactory('AddressTester')
+    addressTester = (await factory.deploy()) as AddressTester
+
+    const f1 = await ethers.getContractFactory('AddressTesterCaller')
+    addressTesterCaller = (await f1.deploy(addressTester.address)) as AddressTesterCaller
+  })
+
+  after(async () => {
+    // Disable mainnet forking to avoid effecting other tests.
+    await hre.network.provider.request({
+      method: 'hardhat_reset',
+      params: [],
+    })
+  })
+
+  it('1111', async () => {
+    console.log('a')
+    await addressTester.callStatic.validate('0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2')
+    const signer = (await ethers.getSigners())[0]
+
+    // const calldata = addressTester.interface.encodeFunctionData('validate', [
+    //   '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    // ])
+    const calldata1 = '0x207c64fb000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+    const calldata2 = '0x207c64fb00000000eeeeeeeeeeeeeeeec02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'
+
+    console.log('x')
+    await signer.call({ data: calldata1, to: addressTester.address })
+    console.log('z')
+    await signer.call({ data: calldata2, to: addressTester.address })
+  })
+
+  it('2222', async () => {
+    console.log('ZZZZZ')
+    await addressTesterCaller.callStatic.validate()
+  })
+})