@paraswap/dex-lib 3.5.4-v6.2.0 → 3.5.4-v6.2.1

package/src/dex/maker-psm/scripts/validate-state.ts

@@ -0,0 +1,221 @@
+// /* eslint-disable no-console */
+// import dotenv from 'dotenv';
+// dotenv.config();
+
+// import { Network } from '../../../constants';
+// import { DummyDexHelper } from '../../../dex-helper';
+// import { BlockHeader } from 'web3-eth';
+// import { MakerPsmConfig } from '../config';
+// import { BigNumber, ethers } from 'ethers';
+// import { Interface } from '@ethersproject/abi';
+// import _ from 'lodash';
+// import vatABI from './vat.abi.json';
+// import gemABI from './gem.abi.json';
+// // @ts-ignore
+// import { Tokens } from '../../../../tests/constants-e2e';
+
+// const tokens = Tokens[Network.MAINNET];
+
+// const vatInterface = new Interface(vatABI);
+// const gemInterface = new Interface(gemABI);
+// const erc20Interface = new Interface([
+//   {
+//     constant: true,
+//     inputs: [{ internalType: 'address', name: '', type: 'address' }],
+//     name: 'balanceOf',
+//     outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+//     payable: false,
+//     stateMutability: 'view',
+//     type: 'function',
+//   },
+// ]);
+
+// const network = Network.MAINNET;
+// const vat = MakerPsmConfig.MakerPsm[Network.MAINNET].vatAddress;
+// const MOVE_TOPIC =
+//   '0xbb35783b00000000000000000000000000000000000000000000000000000000';
+
+// const dexHelper = new DummyDexHelper(network);
+
+// async function findNewGems(): Promise<boolean> {
+//   const network = Network.MAINNET;
+//   const dexHelper = new DummyDexHelper(network);
+
+//   const lastBlockNumber = await dexHelper.provider.getBlockNumber();
+
+//   const startBlockNumber = lastBlockNumber - 1_000_000;
+//   const endBlockNumber = lastBlockNumber;
+//   // const startBlockNumber = endBlockNumber - 700_000;
+
+//   const totalRange = endBlockNumber - startBlockNumber;
+
+//   const smallChunkSize = 10_000;
+//   const bigChunkSize = 100_000;
+
+//   const bigChunks = Math.ceil(totalRange / bigChunkSize);
+
+//   const smallChunks = Math.ceil(bigChunkSize / smallChunkSize);
+
+//   const uniquePotentialGemJoinsSet = new Set();
+
+//   for (let i = 0; i < bigChunks; i++) {
+//     console.log('Processing chunk', i + 1, 'of', bigChunks);
+//     const from = startBlockNumber + i * bigChunkSize;
+//     console.log(
+//       new Array(smallChunks).fill(0).map((_, smallChunkNumber) => ({
+//         fromBlock: from + smallChunkNumber * smallChunkSize,
+//         toBlock: from + smallChunkNumber * smallChunkSize + smallChunkSize,
+//       })),
+//     );
+
+//     const logsToDispatch = (
+//       await Promise.all(
+//         new Array(smallChunks).fill(0).map((_, smallChunkNumber) =>
+//           dexHelper.provider.getLogs({
+//             fromBlock: from + smallChunkNumber * smallChunkSize,
+//             toBlock: from + smallChunkNumber * smallChunkSize + smallChunkSize,
+//             address: vat,
+//           }),
+//         ),
+//       )
+//     ).flat();
+
+//     const moveLogs = logsToDispatch.filter(l => l.topics[0] === MOVE_TOPIC);
+
+//     const potentialGemJoins = moveLogs.map(
+//       l => ethers.utils.defaultAbiCoder.decode(['address'], l.topics[1])[0],
+//     );
+
+//     potentialGemJoins.forEach(gemJoin =>
+//       uniquePotentialGemJoinsSet.add(gemJoin),
+//     );
+//   }
+
+//   const uniquePotentialGemJoins = Array.from(uniquePotentialGemJoinsSet);
+//   console.log('unique potential gem joins', uniquePotentialGemJoins.length);
+
+//   const gemJoinCalldata = uniquePotentialGemJoins
+//     .map(gemJoin => {
+//       return [
+//         {
+//           target: gemJoin,
+//           callData: vatInterface.encodeFunctionData('gemJoin'),
+//         },
+//       ];
+//     })
+//     .flat();
+
+//   const slicedGemJoinCallData = _.chunk(gemJoinCalldata, 500);
+
+//   const gemJoinData = (
+//     await Promise.all(
+//       slicedGemJoinCallData.map(async _multiCallData =>
+//         dexHelper.multiContract.methods
+//           .tryAggregate(false, _multiCallData)
+//           .call({}),
+//       ),
+//     )
+//   ).flat();
+
+//   // console.log(
+//   //   gemJoinData
+//   //     .map((data, i) => ({ ...data, index: i }))
+//   //     .filter(d => d.returnData !== '0x' && d.returnData.length === 66)
+//   //     .map(d => [d.returnData, gemJoinCalldata[d.index]]),
+//   // );
+
+//   const gemJoins = gemJoinData
+//     .filter(d => d.returnData !== '0x' && d.returnData.length === 66)
+//     .map(
+//       d => ethers.utils.defaultAbiCoder.decode(['address'], d.returnData)[0],
+//     );
+
+//   const uniqueGemJoins = [...new Set(gemJoins)];
+//   console.log('unique gem joins', uniqueGemJoins.length);
+
+//   const gemCalldata = uniqueGemJoins
+//     .map(gemJoin => {
+//       return [
+//         {
+//           target: gemJoin,
+//           callData: gemInterface.encodeFunctionData('gem'),
+//         },
+//       ];
+//     })
+//     .flat();
+
+//   const returnGemData = await dexHelper.multiContract.methods
+//     .tryAggregate(false, gemCalldata)
+//     .call({});
+
+//   const gems = returnGemData
+//     .filter((d: any) => d.returnData !== '0x')
+//     .map(
+//       (d: any) =>
+//         ethers.utils.defaultAbiCoder.decode(['address'], d.returnData)[0],
+//     );
+
+//   const balanceCalldata = gems
+//     .map((gem: any, i: number) => {
+//       return [
+//         {
+//           target: gem,
+//           callData: erc20Interface.encodeFunctionData('balanceOf', [
+//             uniqueGemJoins[i],
+//           ]),
+//         },
+//       ];
+//     })
+//     .flat();
+
+//   const returnBalanceData = await dexHelper.multiContract.methods
+//     .tryAggregate(false, balanceCalldata)
+//     .call({});
+
+//   console.log(returnBalanceData);
+
+//   const balances: BigNumber[] = returnBalanceData
+//     .filter((d: any) => d.returnData !== '0x')
+//     .map(
+//       (d: any) =>
+//         ethers.utils.defaultAbiCoder.decode(['uint256'], d.returnData)[0],
+//     );
+
+//   console.log(balances.map(b => b.toString()));
+
+//   const data = uniqueGemJoins.map((gemJoin, i) => {
+//     const token = Object.values(tokens).find(
+//       t => t.address.toLowerCase() === gems[i].toLowerCase(),
+//     );
+//     const symbol = token
+//       ? Object.entries(tokens).find(
+//           ([symbol, t]) => t.address.toLowerCase() === gems[i].toLowerCase(),
+//         )?.[0]
+//       : 'Not found';
+//     const balance = token
+//       ? Number(ethers.utils.formatUnits(balances[i], token.decimals))
+//       : balances[i].toString();
+
+//     return {
+//       gemJoin,
+//       gem: gems[i],
+//       balance,
+//       ...(token
+//         ? {
+//             address: gems[i],
+//             decimals: token.decimals,
+//             symbol,
+//           }
+//         : { address: gems[i] }),
+//     };
+//   });
+
+//   console.log(data);
+
+//   // const address = logsToDispatch[0].address;
+//   return true;
+// }
+
+// findNewGems()
+//   .then(() => console.log('Done'))
+//   .catch(e => console.error(e));

package/src/dex/maker-psm/scripts/vat.abi.json

@@ -0,0 +1,243 @@
+[
+  {
+    "inputs": [
+      { "internalType": "address", "name": "gemJoin_", "type": "address" },
+      { "internalType": "address", "name": "daiJoin_", "type": "address" },
+      { "internalType": "address", "name": "vow_", "type": "address" }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "fee",
+        "type": "uint256"
+      }
+    ],
+    "name": "BuyGem",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "address",
+        "name": "user",
+        "type": "address"
+      }
+    ],
+    "name": "Deny",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "bytes32",
+        "name": "what",
+        "type": "bytes32"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "data",
+        "type": "uint256"
+      }
+    ],
+    "name": "File",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "address",
+        "name": "user",
+        "type": "address"
+      }
+    ],
+    "name": "Rely",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "fee",
+        "type": "uint256"
+      }
+    ],
+    "name": "SellGem",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "usr", "type": "address" },
+      { "internalType": "uint256", "name": "gemAmt", "type": "uint256" }
+    ],
+    "name": "buyGem",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "dai",
+    "outputs": [
+      { "internalType": "contract DaiAbstract", "name": "", "type": "address" }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "daiJoin",
+    "outputs": [
+      {
+        "internalType": "contract DaiJoinAbstract",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [{ "internalType": "address", "name": "usr", "type": "address" }],
+    "name": "deny",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "bytes32", "name": "what", "type": "bytes32" },
+      { "internalType": "uint256", "name": "data", "type": "uint256" }
+    ],
+    "name": "file",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "gemJoin",
+    "outputs": [
+      {
+        "internalType": "contract AuthGemJoinAbstract",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [{ "internalType": "address", "name": "usr", "type": "address" }],
+    "name": "hope",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "ilk",
+    "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [{ "internalType": "address", "name": "usr", "type": "address" }],
+    "name": "nope",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [{ "internalType": "address", "name": "usr", "type": "address" }],
+    "name": "rely",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "usr", "type": "address" },
+      { "internalType": "uint256", "name": "gemAmt", "type": "uint256" }
+    ],
+    "name": "sellGem",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "tin",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "tout",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "vat",
+    "outputs": [
+      { "internalType": "contract VatAbstract", "name": "", "type": "address" }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "vow",
+    "outputs": [{ "internalType": "address", "name": "", "type": "address" }],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [{ "internalType": "address", "name": "", "type": "address" }],
+    "name": "wards",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

package/src/dex/maker-psm/types.ts

@@ -1,4 +1,4 @@
-import { Address, Token } from '../../types';
+import { Address, NumberAsString, Token } from '../../types';
 
 export type PoolState = {
   tin: bigint; // toll in
@@ -13,6 +13,7 @@ export type MakerPsmData = {
   gemJoinAddress: Address;
   gemDecimals: number;
   toll: string;
+  isApproved?: boolean;
 };
 
 export type PoolConfig = {
@@ -27,3 +28,18 @@ export type DexParams = {
   vatAddress: Address;
   pools: PoolConfig[];
 };
+
+export type MakerPsmParams = [
+  srcToken: Address,
+  destToken: Address,
+  fromAmount: NumberAsString,
+  toAmount: NumberAsString,
+  toll: NumberAsString,
+  to18ConversionFactor: NumberAsString,
+  exchange: Address,
+  gemJoinAddress: Address,
+  metadata: string,
+  beneficiaryDirectionApproveFlag: NumberAsString,
+];
+
+export type MakerPsmDirectPayload = [params: MakerPsmParams, permit: string];

package/src/dex/uniswap-v2/uniswap-v2.ts

@@ -938,7 +938,7 @@ export class UniswapV2
     deadline: NumberAsString,
     partner: string,
     beneficiary: string,
-    contractMethod?: string,
+    contractMethod: string,
   ): TxInfo<UniswapParam> {
     if (!contractMethod) throw new Error(`contractMethod need to be passed`);
     if (permit !== '0x') contractMethod += 'WithPermit';
@@ -1014,7 +1014,7 @@ export class UniswapV2
     partnerAndFee: string,
     beneficiary: string,
     blockNumber: number,
-    contractMethod?: string,
+    contractMethod: string,
   ) {
     if (!contractMethod) throw new Error(`contractMethod need to be passed`);
     if (!UniswapV2.getDirectFunctionNameV6().includes(contractMethod!)) {

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -960,7 +960,7 @@ export class UniswapV3
     deadline: NumberAsString,
     partner: string,
     beneficiary: string,
-    contractMethod?: string,
+    contractMethod: string,
   ): TxInfo<UniswapV3Param> {
     if (!UniswapV3.getDirectFunctionName().includes(contractMethod!)) {
       throw new Error(`Invalid contract method ${contractMethod}`);
@@ -1023,7 +1023,7 @@ export class UniswapV3
     partnerAndFee: string,
     beneficiary: string,
     blockNumber: number,
-    contractMethod?: string,
+    contractMethod: string,
   ) {
     if (!UniswapV3.getDirectFunctionNameV6().includes(contractMethod!)) {
       throw new Error(`Invalid contract method ${contractMethod}`);

package/src/dex/zerox/index.ts

@@ -275,7 +275,7 @@ export class ZeroX
     deadline: NumberAsString,
     partner: string,
     beneficiary: string,
-    contractMethod?: string,
+    contractMethod: string,
   ): TxInfo<ZeroXParam> {
     const usePermit = permit !== '0x';
     const encoder = (...params: ZeroXParam) => {

package/tests/constants-e2e.ts

@@ -1314,7 +1314,7 @@ export const Holders: {
     CVX: '0x0aCA67Fa70B142A3b9bF2eD89A81B40ff85dACdC',
     MIM: '0xa046a8660e66d178ee07ec97c585eeb6aa18c26c',
     AnkETH: '0xF7260D4ADc48fEefd5a19a9Eb23f9747CeE15C92',
-    DAI: '0x2fEb1512183545f48f6b9C5b4EbfCaF49CfCa6F3',
+    DAI: '0xd1668fb5f690c59ab4b0cabad0f8c1617895052b',
     oldFRAX: '0x183d0dc5867c01bfb1dbbc41d6a9d3de6e044626',
     newFRAX: '0x183d0dc5867c01bfb1dbbc41d6a9d3de6e044626',
     FEI: '0x19c549357034d10db8d75ed812b45be1dd8a7218',